Class: Lutaml::Xsd::SchemaRepository::QualifiedNameParser

Inherits:
Object
  • Object
show all
Defined in:
lib/lutaml/xsd/schema_repository/qualified_name_parser.rb

Overview

Internal helper for parsing qualified type names Supports multiple notations:

Class Method Summary collapse

Class Method Details

.parse(qname, namespace_registry) ⇒ Hash

Parse a qualified name into its components

Parameters:

  • qname (String) —

    The qualified name to parse

  • namespace_registry (NamespaceRegistry) —

    Registry for prefix lookups

Returns:

  • (Hash) —

    Parsed components with :prefix, :namespace, :local_name



16
17
18
19
20
21
22
23
24
25
26
27
28
29
 
# File 'lib/lutaml/xsd/schema_repository/qualified_name_parser.rb', line 16

def self.parse(qname, namespace_registry)
  return nil if qname.nil? || qname.empty?

  # Check for Clark notation: {http://...}LocalName
  if qname.start_with?("{")
    parse_clark_notation(qname)
  # Check for prefixed QName: prefix:LocalName
  elsif qname.include?(":")
    parse_prefixed_qname(qname, namespace_registry)
  # Unprefixed name - use default namespace
  else
    parse_unprefixed(qname, namespace_registry)
  end
end

.parse_clark_notation(qname) ⇒ Hash

Parse Clark notation: namespaceLocalName

Parameters:

  • qname (String) —

    The Clark notation string

Returns:

  • (Hash) —

    Parsed components



34
35
36
37
38
39
40
41
42
43
 
# File 'lib/lutaml/xsd/schema_repository/qualified_name_parser.rb', line 34

def self.parse_clark_notation(qname)
  match = qname.match(/^\{([^}]+)\}(.+)$/)
  return nil unless match

  {
    prefix: nil,
    namespace: match[1],
    local_name: match[2],
  }
end

.parse_prefixed_qname(qname, namespace_registry) ⇒ Hash

Parse prefixed QName: prefix:LocalName

Parameters:

  • qname (String) —

    The prefixed QName

  • namespace_registry (NamespaceRegistry) —

    Registry for prefix lookups

Returns:

  • (Hash) —

    Parsed components



49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/lutaml/xsd/schema_repository/qualified_name_parser.rb', line 49

def self.parse_prefixed_qname(qname, namespace_registry)
  parts = qname.split(":", 2)
  return nil if parts.size != 2

  prefix = parts[0]
  local_name = parts[1]
  namespace = namespace_registry.get_uri(prefix)

  {
    prefix: prefix,
    namespace: namespace,
    local_name: local_name,
  }
end

.parse_unprefixed(qname, namespace_registry) ⇒ Hash

Parse unprefixed name using default namespace

Parameters:

  • qname (String) —

    The local name

  • namespace_registry (NamespaceRegistry) —

    Registry for default namespace

Returns:

  • (Hash) —

    Parsed components



68
69
70
71
72
73
74
 
# File 'lib/lutaml/xsd/schema_repository/qualified_name_parser.rb', line 68

def self.parse_unprefixed(qname, namespace_registry)
  {
    prefix: nil,
    namespace: namespace_registry.default_namespace,
    local_name: qname,
  }
end

.to_clark_notation(parsed) ⇒ String

Convert parsed components back to Clark notation

Parameters:

  • parsed (Hash) —

    Parsed components with :namespace and :local_name

Returns:

  • (String) —

    Clark notation string



79
80
81
82
83
84
85
86
87
 
# File 'lib/lutaml/xsd/schema_repository/qualified_name_parser.rb', line 79

def self.to_clark_notation(parsed)
  return nil unless parsed && parsed[:local_name]

  if parsed[:namespace]
    "{#{parsed[:namespace]}}#{parsed[:local_name]}"
  else
    parsed[:local_name]
  end
end