Class: Lutaml::Xml::NamespaceTypeResolver

Inherits:
Object
  • Object
show all
Defined in:
lib/lutaml/xml/namespace_type_resolver.rb

Overview

Namespace-aware wrapper for TypeResolver

This class provides namespace-aware type resolution WITHOUT modifying the stateless TypeResolver design. It acts as a wrapper that adds namespace context to type resolution.

Examples:

Basic usage

resolver = NamespaceTypeResolver.new(context)
type = resolver.resolve_type(:string, namespace: MyNamespace)

Resolve types by namespace URI

types = NamespaceTypeResolver.resolve_by_namespace_uri(
  "http://example.com/ns",
  context
)

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(context) ⇒ NamespaceTypeResolver

Create a new NamespaceTypeResolver

Parameters:

  • context (Object) —

    the context for type resolution



28
29
30
 
# File 'lib/lutaml/xml/namespace_type_resolver.rb', line 28

def initialize(context)
  @context = context
end

Instance Attribute Details

#context ⇒ Object (readonly)

Returns the context for type resolution.

Returns:

  • (Object) —

    the context for type resolution



23
24
25
 
# File 'lib/lutaml/xml/namespace_type_resolver.rb', line 23

def context
  @context
end

Class Method Details

.type_in_namespace?(type_class, namespace) ⇒ Boolean

Check if a type is in a specific namespace

Parameters:

  • type_class (Class) —

    the type class to check

  • namespace (Class) —

    the namespace class to check against

Returns:

  • (Boolean) —

    true if type is in the namespace



76
77
78
79
80
81
82
83
 
# File 'lib/lutaml/xml/namespace_type_resolver.rb', line 76

def self.type_in_namespace?(type_class, namespace)
  return false unless type_class.is_a?(Class) && type_class <= Lutaml::Model::Type::Value

  type_ns = type_class.namespace_class
  return false unless type_ns

  type_ns == namespace || type_ns.uri == namespace.uri
end

.type_namespace_uri(type_class) ⇒ String?

Get the namespace URI for a type

Parameters:

  • type_class (Class) —

    the type class

Returns:

  • (String, nil) —

    the namespace URI or nil



89
90
91
92
93
94
95
96
 
# File 'lib/lutaml/xml/namespace_type_resolver.rb', line 89

def self.type_namespace_uri(type_class)
  return nil unless type_class.is_a?(Class) && type_class <= Lutaml::Model::Type::Value

  type_ns = type_class.namespace_class
  return nil unless type_ns

  type_ns.respond_to?(:uri) ? type_ns.uri : nil
end

Instance Method Details

#resolve_type(name, namespace: nil) ⇒ Class?

Resolve a type with optional namespace validation

Examples:

Resolve without namespace check

resolver.resolve_type(:string)

Resolve with namespace validation

resolver.resolve_type(:string, namespace: MyNamespace)

Parameters:

  • name (Symbol, String) —

    the type name to resolve

  • namespace (Class, nil) (defaults to: nil) —

    optional namespace class to validate against

Returns:

  • (Class, nil) —

    the resolved type class

Raises:

  • (NamespaceMismatchError) —

    if namespace doesn’t match type’s namespace



44
45
46
47
48
49
50
51
 
# File 'lib/lutaml/xml/namespace_type_resolver.rb', line 44

def resolve_type(name, namespace: nil)
  type = Lutaml::Model::TypeResolver.resolve(name, context)
  return type unless namespace
  return type unless type

  validate_namespace_match!(type, namespace)
  type
end

#resolve_types_by_namespace(uri) ⇒ Array<Class>

Resolve all types in a given namespace

Examples:

Find all types in a namespace

types = resolver.resolve_types_by_namespace("http://example.com/ns")

Parameters:

  • uri (String) —

    the namespace URI to search for

Returns:

  • (Array<Class>) —

    array of type classes in that namespace



60
61
62
63
64
65
66
67
68
69
 
# File 'lib/lutaml/xml/namespace_type_resolver.rb', line 60

def resolve_types_by_namespace(uri)
  return [] unless context.respond_to?(:registry)

  context.registry.types.select do |_name, type_class|
    next false unless type_class <= Lutaml::Model::Type::Value

    type_ns = type_class.namespace_class
    type_ns&.uri == uri
  end.values
end