lutaml-model 0.8.16 → 0.8.18

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