Class: Lutaml::Model::Schema::RngCompiler::ElementVisitor

Inherits:
Object
  • Object
show all
Defined in:
lib/lutaml/model/schema/rng_compiler/element_visitor.rb

Overview

Walks an RNG / subtree and produces Definitions::Model / Definitions::RestrictedType / Definitions::UnionType objects, registered in the shared classes hash.

Supported constructs:

element, attribute, ref, text, data, value, empty,
optional, zeroOrMore, oneOrMore, group, choice, mixed, list,
interleave

Shape classification (define-wraps-data, define-wraps-enum-choice, union) is delegated to DefineClassifier. Value-shape resolution for individual children is delegated to ValueTypeResolver.

Constant Summary collapse

DISPATCHABLE_KINDS = 
%i[
  element attribute ref group optional oneOrMore zeroOrMore
  choice list interleave empty
].freeze
REPETITION_CTX = 
{
  zeroOrMore: { collection: (0..Float::INFINITY), initialize_empty: true },
  oneOrMore: { collection: (1..Float::INFINITY), initialize_empty: true },
  list: { collection: (0..Float::INFINITY), initialize_empty: true },
}.freeze
HANDLERS = 
{
  element: :handle_element,
  attribute: :handle_attribute,
  ref: :handle_ref,
  group: :handle_group,
  optional: :handle_optional,
  oneOrMore: :handle_repeating,
  zeroOrMore: :handle_repeating,
  list: :handle_repeating,
  choice: :handle_choice,
  interleave: :handle_interleave,
  empty: :handle_empty,
}.freeze

Instance Method Summary collapse

Constructor Details

#initialize(defines, classes, default_namespace_class: nil, register_namespace: nil) ⇒ ElementVisitor

Returns a new instance of ElementVisitor.



45
46
47
48
49
50
51
52
53
54
55
56
 
# File 'lib/lutaml/model/schema/rng_compiler/element_visitor.rb', line 45

def initialize(defines, classes, default_namespace_class: nil,
               register_namespace: nil)
  @defines = defines
  @classes = classes
  @default_namespace_class = default_namespace_class
  @register_namespace = register_namespace
  @value_type_resolver = ValueTypeResolver.new(
    defines, classes,
    compile_define: method(:compile_define),
    register_class: method(:register_class!)
  )
end

Instance Method Details

#compile_define(define) ⇒ Object

Compile a into a class.

  • Define body matches a simple-type shape -> RestrictedType/UnionType.
  • Wraps exactly one element -> rooted Definitions::Model.
  • Multiple or zero wrapped elements -> fragment Definitions::Model.


75
76
77
78
79
80
81
82
83
84
85
 
# File 'lib/lutaml/model/schema/rng_compiler/element_visitor.rb', line 75

def compile_define(define)
  class_name = Utils.camel_case(define.name)
  return @classes[class_name] if @classes.key?(class_name)

  if (simple = DefineClassifier.build(define, class_name))
    register_class!(simple)
    return simple
  end

  build_complex_define(define, class_name)
end

#compile_element(element) ⇒ Object

Compile a top-level . Always becomes a rooted model.



59
60
61
62
63
64
65
66
67
68
69
 
# File 'lib/lutaml/model/schema/rng_compiler/element_visitor.rb', line 59

def compile_element(element)
  class_name = Utils.camel_case(element.attr_name)
  model = @classes[class_name] ||= Definitions::Model.new(
    class_name: class_name,
    xml_root: Definitions::XmlRoot.new(kind: :element, name: element.attr_name),
    documentation: documentation_text(element),
    namespace_class_name: namespace_class_for(element),
  )
  visit_content(element, model)
  model
end