lutaml-model 0.8.17 → 0.8.18

data/lib/lutaml/model/schema/renderers/required_files_calculator.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Renderers
+        # Computes the `require_relative` / `require` lines that a
+        # generated Definitions::Model needs at the top of its file.
+        #
+        # XSD and RNG have different strategies because their type
+        # references mean different things:
+        #
+        # - XSD attributes carry TypeRef(:w3c | :symbol | :class_ref):
+        #     :w3c       -> require "lutaml/xml/w3c"
+        #     :symbol    -> require_relative "<value>"
+        #                    (unless the value is a skippable built-in)
+        #                    decimal is special: require "bigdecimal"
+        #     :class_ref -> no require (class is autoloaded by registry)
+        #   Plus any required_files surfaced by simple_content + the
+        #   namespace class.
+        #
+        # - RNG attributes only ever reference other generated classes
+        #   via :class_ref, so the calculator only collects class names
+        #   (imports + class_ref types + namespace) and the caller
+        #   formats them as `require_relative "snake_case_name"`.
+        module RequiredFilesCalculator
+          module_function
+
+          # XSD strategy. `skippable_type?` is a one-arg predicate the
+          # caller supplies so the calculator doesn't have to know the
+          # XSD built-in type table.
+          def for_xml(model, skippable_type:)
+            deps = []
+            Definitions::MemberWalk.each_attribute(model.members) do |attr|
+              deps.concat(xml_attribute_requires(attr, skippable_type))
+            end
+            deps.concat(simple_content_requires(model.simple_content, skippable_type))
+            deps << namespace_require(model.namespace_class_name) if model.namespace_class_name
+            deps.uniq
+          end
+
+          # RNG strategy. Returns the de-duplicated list of generated-class
+          # names the model depends on; caller wraps as `require_relative`.
+          def class_names_for_rng(model)
+            deps = model.imports.dup
+            Definitions::MemberWalk.each_attribute(model.members) do |attr|
+              deps << attr.type.value if attr.type.kind == :class_ref
+            end
+            deps << model.namespace_class_name if model.namespace_class_name
+            deps.uniq
+          end
+
+          def namespace_require(class_name)
+            %(require_relative "#{Utils.snake_case(class_name)}")
+          end
+
+          def xml_attribute_requires(attr, skippable_type)
+            ref = attr.type
+            return [] unless ref
+
+            case ref.kind
+            when :w3c       then ['require "lutaml/xml/w3c"']
+            when :symbol    then xml_symbol_requires(ref.value, skippable_type)
+            when :class_ref then []
+            else []
+            end
+          end
+
+          def xml_symbol_requires(value, skippable_type)
+            return [%(require "bigdecimal")] if value == "decimal"
+            return [] if skippable_type.call(value)
+
+            [%(require_relative "#{value}")]
+          end
+
+          # base_class arrives as a raw XSD name (e.g. "xs:dateTime"). The
+          # built-in skippable check keys on the XSD spelling (`:dateTime`),
+          # not the snake_case file form, so test against `local` directly
+          # before emitting the require_relative.
+          def simple_content_requires(simple_content, skippable_type)
+            return [] if simple_content.nil? || simple_content.base_class.nil?
+
+            local = Utils.last_of_split(simple_content.base_class)
+            return [%(require "bigdecimal")] if local == "decimal"
+            return [] if skippable_type.call(local)
+
+            [%(require_relative "#{Utils.snake_case(local)}")]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/renderers/restricted_type.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Lutaml
+  module Model
+    module Schema
+      module Renderers
+        # Renders a Definitions::RestrictedType into a Ruby class extending
+        # a Lutaml::Model::Type::* with a cast body that mutates options
+        # with facet values and delegates to super.
+        class RestrictedType < Base
+          def render
+            Templates::RESTRICTED_SIMPLE_TYPE.result(binding)
+          end
+
+          private
+
+          def rendered_class_name = @spec.class_name
+          def parent_class = @spec.parent_class
+
+          def xml_namespace_line
+            ns = @spec.namespace_class_name
+            ns && "namespace #{ns}"
+          end
+
+          def restricted_simple_type_required_files = required_files_block
+
+          def restricted_simple_type_cast_body
+            [
+              render_min_max,
+              render_pattern,
+              render_enumerations,
+              render_transform,
+            ].compact.join
+          end
+
+          def render_min_max
+            f = @spec.facets
+            max = f.max_inclusive || f.max_exclusive
+            min = f.min_inclusive || f.min_exclusive
+            return nil unless max || min
+
+            out = +""
+            out << "#{@extended_indent}options[:max] = #{max}\n" if max
+            out << "#{@extended_indent}options[:min] = #{min}\n" if min
+            out
+          end
+
+          def render_pattern
+            p = @spec.facets.pattern
+            p && "#{@extended_indent}options[:pattern] = %r{#{p}}\n"
+          end
+
+          def render_enumerations
+            e = @spec.facets.enumerations
+            return nil if e.nil? || e.empty?
+
+            casted = e.map { |v| "super(#{v.inspect})" }.join(", ")
+            "#{@extended_indent}options[:values] = [#{casted}]\n"
+          end
+
+          def render_transform
+            t = @spec.transform_facet
+            t && "#{@extended_indent}value = #{t.expression}\n"
+          end
+
+          def registration_methods
+            Registration.methods_block(
+              class_name: @spec.class_name,
+              module_namespace: @module_namespace,
+              indent: @indent,
+              lazy: true,
+              keep_when_namespaced: @spec.keep_register_when_namespaced,
+            )
+          end
+
+          def registration_execution
+            Registration.execution_line(
+              class_name: @spec.class_name,
+              module_namespace: @module_namespace,
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/renderers/union.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "erb"
+
+module Lutaml
+  module Model
+    module Schema
+      module Renderers
+        # Renders a Definitions::UnionType into a
+        # Lutaml::Model::Type::Value subclass with a cast body whose
+        # strategy is chosen from the spec.
+        class Union < Base
+          def render
+            Templates::UNION_TYPE.result(binding)
+          end
+
+          private
+
+          def rendered_class_name = @spec.class_name
+
+          def union_required_files = required_files_block
+
+          def union_cast_body
+            case @spec.cast_strategy
+            when :resolve_type then resolve_type_body
+            when :class_refs   then class_refs_body
+            end
+          end
+
+          def resolve_type_body
+            chain = @spec.members.map { |m| resolve_type_call(m) }
+            "#{@extended_indent}#{chain.join(" ||\n  ")}\n"
+          end
+
+          def resolve_type_call(type_ref)
+            "Lutaml::Model::GlobalContext.resolve_type(:#{type_ref.value}, @register).cast(value, options)"
+          end
+
+          def class_refs_body
+            classes = @spec.members.map { |m| literal_class(m) }.join(", ")
+            sp2 = @extended_indent
+            <<~BODY
+              #{sp2}[#{classes}].each do |t|
+              #{sp2}  begin
+              #{sp2}    casted = t.cast(value, options)
+              #{sp2}    return casted unless casted.nil?
+              #{sp2}  rescue StandardError
+              #{sp2}    next
+              #{sp2}  end
+              #{sp2}end
+              #{sp2}value
+            BODY
+          end
+
+          def literal_class(type_ref)
+            case type_ref.kind
+            when :class_ref then type_ref.value
+            when :w3c       then "::#{type_ref.value}"
+            when :symbol    then "Lutaml::Model::GlobalContext.resolve_type(:#{type_ref.value})"
+            end
+          end
+
+          def registration_methods
+            Registration.methods_block(
+              class_name: @spec.class_name,
+              module_namespace: @module_namespace,
+              indent: @indent,
+              lazy: @spec.lazy_register,
+              keep_when_namespaced: @spec.keep_register_when_namespaced,
+            )
+          end
+
+          def registration_execution
+            Registration.execution_line(
+              class_name: @spec.class_name,
+              module_namespace: @module_namespace,
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/renderers.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Renderers
+        autoload :Base,         "#{__dir__}/renderers/base"
+        autoload :Registration, "#{__dir__}/renderers/registration"
+        autoload :RequiredFilesCalculator, "#{__dir__}/renderers/required_files_calculator"
+        autoload :MemberDecls,    "#{__dir__}/renderers/member_decls"
+        autoload :Mappings,       "#{__dir__}/renderers/mappings"
+        autoload :Model,          "#{__dir__}/renderers/model"
+        autoload :RestrictedType, "#{__dir__}/renderers/restricted_type"
+        autoload :Union,          "#{__dir__}/renderers/union"
+        autoload :Namespace,      "#{__dir__}/renderers/namespace"
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/rnc_compiler/source_resolver.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module RncCompiler
+        # Resolves RNC input text and the base directory used for relative
+        # include paths.
+        module SourceResolver
+          ResolvedSource =
+            Struct.new(:text, :base_dir, :path, keyword_init: true)
+
+          module_function
+
+          def resolve(input, options)
+            location = options[:location].to_s
+            return string_source(input) if location.empty?
+
+            expanded = File.expand_path(location)
+            if File.file?(expanded)
+              return file_source(expanded) if input.nil? || input.to_s.empty?
+
+              return string_source(input, base_dir: File.dirname(expanded), path: expanded)
+            end
+            return string_source(input, base_dir: expanded) if File.directory?(expanded)
+
+            string_source(input)
+          end
+
+          def string_source(input, base_dir: nil, path: nil)
+            ResolvedSource.new(text: input.to_s, base_dir: base_dir, path: path)
+          end
+
+          def file_source(path)
+            ResolvedSource.new(
+              text: File.read(path),
+              base_dir: File.dirname(path),
+              path: path,
+            )
+          end
+
+          private_class_method :string_source, :file_source
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/rnc_compiler.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      # Compiles RELAX NG Compact Syntax (RNC) into Lutaml::Model Ruby source.
+      #
+      # RNC support is a thin adapter: the rng gem parses the compact syntax
+      # into Rng::Grammar — resolving includes, bracket annotations, and
+      # non-leading `start` definitions natively — then RngCompiler performs all
+      # model generation and output handling.
+      module RncCompiler
+        extend self
+
+        autoload :SourceResolver, "#{__dir__}/rnc_compiler/source_resolver"
+
+        DEFAULT_OUTPUT_DIR_PREFIX = "rnc_models"
+
+        def to_models(rnc, options = {})
+          require_rnc_parser!
+
+          grammar = parse_grammar(rnc, options)
+
+          RngCompiler.to_models(
+            grammar,
+            options.merge(default_output_dir: default_output_dir),
+          )
+        end
+
+        def parse_grammar(rnc, options)
+          return rnc if rnc.is_a?(::Rng::Grammar)
+
+          source = SourceResolver.resolve(rnc, options)
+          ::Rng.parse_rnc(source.text, location: source.path || source.base_dir)
+        end
+
+        def require_rnc_parser!
+          return if rnc_parser_available?
+
+          raise "RNC schema compilation requires an rng gem whose " \
+                "`Rng.parse_rnc` accepts a `location:` option (for native " \
+                "include resolution). Point your Gemfile at an rng version " \
+                "that provides it."
+        end
+
+        # rng gained the `location:` option (native include resolution) after
+        # the 0.3.7 release; the released parse_rnc takes only `(rnc)`.
+        def rnc_parser_available?
+          defined?(::Rng::Grammar) && ::Rng.respond_to?(:parse_rnc) &&
+            ::Rng.method(:parse_rnc).parameters.any? { |_type, name| name == :location }
+        end
+
+        def default_output_dir
+          "#{DEFAULT_OUTPUT_DIR_PREFIX}_#{Time.now.to_i}"
+        end
+
+        private :parse_grammar, :require_rnc_parser!, :rnc_parser_available?,
+                :default_output_dir
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/rng_compiler/define_classifier.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module RngCompiler
+        # Detects the shape of a <define> body and builds the corresponding
+        # Definitions::* spec for it.
+        #
+        #   <data type="X"><param ...>...</param></data>      -> RestrictedType
+        #   <choice><value>a</value><value>b</value></choice> -> RestrictedType (enum)
+        #   <choice><data type="A"/><data type="B"/></choice> -> UnionType
+        #
+        # Returns nil when the define is structural (contains elements or
+        # attributes) — caller falls back to building a Definitions::Model.
+        class DefineClassifier
+          def self.build(define, class_name)
+            new(define, class_name).build
+          end
+
+          def initialize(define, class_name)
+            @define = define
+            @class_name = class_name
+          end
+
+          def build
+            return nil if structural_define?
+
+            union_type || data_restricted_type || enum_restricted_type
+          end
+
+          private
+
+          def structural_define?
+            @define.element.any? || @define.attribute.any?
+          end
+
+          def union_type
+            choice = value_choice
+            return nil unless RngHelpers.pure_union_choice?(choice)
+
+            type_refs = Array(choice.data).map do |d|
+              symbol = RngCompiler::DATA_TYPE_MAP.fetch(
+                d.type, RngCompiler::DEFAULT_DATA_TYPE
+              )
+              Definitions::TypeRef.new(
+                kind: :class_ref,
+                value: RngHelpers.parent_class_for(symbol),
+              )
+            end
+
+            Definitions::UnionType.new(
+              class_name: @class_name,
+              members: type_refs,
+              cast_strategy: :class_refs,
+            )
+          end
+
+          def data_restricted_type
+            data = RngHelpers.single(@define.data)
+            return nil unless data
+
+            base = RngCompiler::DATA_TYPE_MAP.fetch(
+              data.type, RngCompiler::DEFAULT_DATA_TYPE
+            )
+            Definitions::RestrictedType.new(
+              class_name: @class_name,
+              parent_class: RngHelpers.parent_class_for(base),
+              facets: RngHelpers.facet_from_data(data),
+            )
+          end
+
+          def enum_restricted_type
+            choice = value_choice
+            return nil unless RngHelpers.pure_value_choice?(choice)
+
+            Definitions::RestrictedType.new(
+              class_name: @class_name,
+              parent_class: RngHelpers.parent_class_for(:string),
+              facets: RngHelpers.facet_from_values(choice.value),
+            )
+          end
+
+          def value_choice
+            RngHelpers.single(@define.choice)
+          end
+        end
+      end
+    end
+  end
+end