lutaml-model 0.8.17 → 0.8.18

data/lib/lutaml/model/schema/xml_compiler/complex_type.rb

@@ -1,173 +0,0 @@
-module Lutaml
-  module Model
-    module Schema
-      module XmlCompiler
-        class ComplexType
-          attr_accessor :id,
-                        :name,
-                        :mixed,
-                        :instances,
-                        :base_class,
-                        :simple_content
-
-          SERIALIZABLE_BASE_CLASS = "Lutaml::Model::Serializable".freeze
-
-          SIMPLE_CONTENT_ATTRIBUTE_TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
-            <%= @indent %>attribute :content, :<%= simple_content_type %><%= ", collection: true" if mixed && !simple_content? %>
-            <%= simple_content.to_attributes(@indent) if simple_content? -%>
-          TEMPLATE
-
-          TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
-            # frozen_string_literal: true
-
-            require "lutaml/model"
-            <%= required_files.uniq.join("\n") + "\n" -%>
-            <%= module_opening -%>
-            class <%= Utils.camel_case(name) %> < <%= base_class_name %>
-            <%= instances.flat_map { |instance| instance.to_attributes(@indent) }.join + "\n" -%>
-            <%= simple_content_attribute -%>
-            <%= @indent %>xml do
-            <%= extended_indent %>element "<%= name %>"
-            <%= extended_indent %><%= mixed_content? %>
-            <%= namespace_and_prefix %>
-            <%= "\#{extended_indent}map_content to: :content" if simple_content? || mixed %>
-            <%= instances.flat_map { |instance| instance.to_xml_mapping(extended_indent) }.join -%>
-            <%= simple_content.to_xml_mapping(extended_indent) if simple_content? -%>
-            <%= @indent %>end
-            <%= registration_methods -%>
-            end
-            <%= module_closing -%>
-            <%= registration_execution -%>
-          TEMPLATE
-
-          def initialize(base_class: SERIALIZABLE_BASE_CLASS)
-            @base_class = base_class
-            @instances = []
-            @module_namespace = nil
-          end
-
-          def <<(instance)
-            return if instance.nil?
-
-            @instances << instance
-          end
-
-          def simple_content?
-            Utils.present?(@simple_content)
-          end
-
-          def to_class(options: {})
-            setup_options(options)
-            TEMPLATE.result(binding)
-          end
-
-          def required_files
-            files = []
-            # Only include external gem requires, not schema class requires
-            # Schema class dependencies are handled via autoload registry
-            unless @module_namespace
-              files.concat(@instances.map(&:required_files).flatten.compact.uniq)
-              files.concat(simple_content.required_files) if simple_content?
-            end
-            files
-          end
-
-          private
-
-          def setup_options(options)
-            namespace_uri = options[:namespace]
-            @prefix = options[:prefix]
-            @indent = " " * options&.fetch(:indent, 2)
-            @extended_indent = @indent * 2
-            @module_namespace = options[:module_namespace]
-            @modules = @module_namespace&.split("::") || []
-            @register_id = options[:register_id]
-
-            # Get the namespace class name if namespace URI is provided
-            if namespace_uri && XmlCompiler.namespace_classes
-              ns_class = XmlCompiler.namespace_classes.values.find do |ns|
-                ns.uri == namespace_uri
-              end
-              @namespace_class_name = ns_class&.class_name
-            end
-          end
-
-          def module_opening
-            return "" if @modules.empty?
-
-            @modules.map.with_index do |mod, i|
-              "#{'  ' * i}module #{mod}"
-            end.join("\n") + "\n"
-          end
-
-          def module_closing
-            return "" if @modules.empty?
-
-            @modules.reverse.map.with_index do |_mod, i|
-              "#{'  ' * (@modules.size - i - 1)}end"
-            end.join("\n")
-          end
-
-          def registration_methods
-            return "" if @module_namespace
-
-            <<~REGISTRATION
-
-              #{@indent}def self.register
-              #{extended_indent}Lutaml::Model::Config.default_register
-              #{@indent}end
-
-              #{@indent}def self.register_class_with_id
-              #{extended_indent}context = Lutaml::Model::GlobalContext.context(Lutaml::Model::Config.default_register)
-              #{extended_indent}context.registry.register(:#{Utils.snake_case(name)}, self)
-              #{@indent}end
-            REGISTRATION
-          end
-
-          def registration_execution
-            return "" if @module_namespace
-
-            "\n#{Utils.camel_case(name)}.register_class_with_id"
-          end
-
-          def simple_content_type
-            return "string" unless simple_content?
-
-            Utils.snake_case(last_of_split(simple_content.base_class))
-          end
-
-          def simple_content_attribute
-            SIMPLE_CONTENT_ATTRIBUTE_TEMPLATE.result(binding) if simple_content? || mixed
-          end
-
-          def mixed_content?
-            mixed ? "mixed_content" : ""
-          end
-
-          def namespace_and_prefix
-            return "" unless @namespace_class_name
-
-            "#{@extended_indent}namespace #{@namespace_class_name}"
-          end
-
-          def extended_indent
-            @extended_indent
-          end
-
-          def base_class_name
-            case base_class
-            when SERIALIZABLE_BASE_CLASS
-              SERIALIZABLE_BASE_CLASS
-            else
-              Utils.camel_case(last_of_split(base_class))
-            end
-          end
-
-          def last_of_split(field)
-            field&.split(":")&.last
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/model/schema/xml_compiler/element.rb

@@ -1,121 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Model
-    module Schema
-      module XmlCompiler
-        class Element
-          attr_accessor :id,
-                        :ref,
-                        :name,
-                        :type,
-                        :fixed,
-                        :default,
-                        :max_occurs,
-                        :min_occurs
-
-          def initialize(name: nil, ref: nil)
-            @name = name
-            @ref = ref
-          end
-
-          def to_attributes(indent)
-            return if skippable?
-            return unless resolved_type
-
-            "#{indent}attribute :#{resolved_name}, :#{resolved_type}#{attribute_options}\n"
-          end
-
-          def to_xml_mapping(indent)
-            return if skippable?
-            return unless resolved_type
-
-            "#{indent}map_element :#{resolved_name(change_case: false)}, to: :#{resolved_name}#{render_options}\n"
-          end
-
-          def required_files
-            return if skippable?
-
-            element_type = resolved_type(change_case: false)
-            return "require \"bigdecimal\"" if element_type == "decimal"
-            return if SimpleType.skippable?(element_type)
-
-            "require_relative \"#{Utils.snake_case(element_type)}\""
-          end
-
-          private
-
-          def resolved_instance
-            @resolved_instance ||= XmlCompiler.instance_variable_get(:@elements)[last_of_split]
-          end
-
-          def resolved_type(change_case: true)
-            @current_type ||= type || resolved_instance&.type
-            klass_name = last_of_split(@current_type)
-            change_case ? Utils.snake_case(klass_name) : klass_name
-          end
-
-          def resolved_name(change_case: true)
-            @current_name ||= name || resolved_instance&.name
-            change_case ? Utils.snake_case(@current_name) : @current_name
-          end
-
-          def collection_option
-            return if min_occurs.nil? && max_occurs.nil?
-
-            min_value = min_occurs.nil? ? 1 : min_occurs.to_i
-            ", collection: #{min_value}..#{max_value}"
-          end
-
-          def max_value
-            return "Float::INFINITY" if max_occurs == "unbounded"
-            return 1 if max_occurs.nil?
-
-            max_occurs.to_i
-          end
-
-          def default_option
-            return if default.nil?
-
-            ", default: -> { #{default.inspect} }"
-          end
-
-          def render_default_option
-            return if default.nil?
-
-            ", render_default: true"
-          end
-
-          def render_options
-            options = []
-            options << render_default_option if default
-            options << render_empty_option if required?
-            options.compact.join
-          end
-
-          def render_empty_option
-            ", render_empty: true"
-          end
-
-          def required?
-            # Element is required if minOccurs is >= 1 OR minOccurs is nil (schema default is 1)
-            # Only NOT required if minOccurs is explicitly 0
-            min_occurs.nil? || min_occurs.to_i >= 1
-          end
-
-          def attribute_options
-            [collection_option, default_option].compact.join
-          end
-
-          def last_of_split(field = ref)
-            field&.split(":")&.last
-          end
-
-          def skippable?
-            resolved_name == "schema_location"
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/model/schema/xml_compiler/group.rb

@@ -1,113 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Model
-    module Schema
-      module XmlCompiler
-        class Group
-          attr_accessor :name, :ref, :instance
-
-          GROUP_TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
-            # frozen_string_literal: true
-
-            require "lutaml/model"
-            <%=  "\n" + required_files.uniq.join("\n") -%>
-
-            class <%= Utils.camel_case(base_name) %> < Lutaml::Model::Serializable
-            <%= definitions_content %>
-            <%= xml_mapping_block -%>
-
-            <%= @indent %>def self.register
-            <%= extended_indent %>@register ||= Lutaml::Model::Config.default_register
-            <%= @indent %>end
-
-            <%= @indent %>def self.register_class_with_id
-            <%= extended_indent %>context = Lutaml::Model::GlobalContext.context(Lutaml::Model::Config.default_register)
-            <%= extended_indent %>context.registry.register(:<%= Utils.snake_case(base_name) %>, self)
-            <%= @indent %>end
-            end
-
-            <%= Utils.camel_case(base_name) %>.register_class_with_id
-          TEMPLATE
-
-          XML_MAPPING_TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
-            <%= @indent %>xml do
-            <%= extended_indent %>type_name "<%= base_name %>"
-            <%= xml_mapping_content -%>
-            <%= @indent %>end
-          TEMPLATE
-
-          def initialize(name = nil, ref = nil)
-            @name = name
-            @ref = ref
-          end
-
-          def to_xml_mapping(indent = @indent)
-            if Utils.present?(@ref)
-              "#{indent}import_model_mappings :#{Utils.snake_case(base_name)}\n"
-            else
-              @instance.to_xml_mapping(indent * 2)
-            end
-          end
-
-          def to_class(options: {})
-            setup_options(options)
-            GROUP_TEMPLATE.result(binding)
-          end
-
-          def required_files
-            if Utils.blank?(name) && Utils.present?(ref)
-              "require_relative \"#{Utils.snake_case(ref.split(':').last)}\""
-            else
-              @instance&.required_files
-            end
-          end
-
-          def to_attributes(indent = @indent)
-            if Utils.present?(@ref)
-              "#{indent}import_model_attributes :#{Utils.snake_case(base_name)}\n"
-            else
-              @instance.to_attributes(indent)
-            end
-          end
-
-          def base_name
-            (name || ref)&.split(":")&.last
-          end
-
-          private
-
-          def setup_options(options)
-            @indent = " " * options&.fetch(:indent, 2)
-          end
-
-          def definitions_content
-            @definitions_content ||= instance.to_attributes(@indent)
-          end
-
-          def extended_indent
-            @indent * 2
-          end
-
-          def xml_mapping_block
-            XML_MAPPING_TEMPLATE.result(binding)
-          end
-
-          # Generate XML mapping content, unwrapping sequence for importable groups
-          def xml_mapping_content
-            return "" unless instance
-
-            # For Groups (importable models without root), unwrap sequence content
-            # because sequence requires a root element
-            if instance.is_a?(Sequence)
-              # Output sequence content directly without the wrapper
-              instance.xml_block_content(extended_indent)
-            else
-              instance.to_xml_mapping(extended_indent)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/model/schema/xml_compiler/restriction.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Model
-    module Schema
-      module XmlCompiler
-        class Restriction
-          # transform is not a 'xsd' type, but it is used for internal purposes.
-          attr_accessor :min_inclusive,
-                        :max_inclusive,
-                        :min_exclusive,
-                        :max_exclusive,
-                        :enumerations,
-                        :max_length,
-                        :min_length,
-                        :base_class,
-                        :pattern,
-                        :length,
-                        :transform
-
-          MIN_MAX_BOUNDS = ERB.new(<<~TEMPLATE, trim_mode: "-")
-            <%= "\#{indent}options[:max] = \#{max_inclusive || max_exclusive}" if max_bound_exist? %>
-            <%= "\#{indent}options[:min] = \#{min_inclusive || min_exclusive}" if min_bound_exist? %>
-          TEMPLATE
-
-          PATTERN = ERB.new(<<~TEMPLATE, trim_mode: "-")
-            <%= "\#{indent}options[:pattern] = %r{\#{pattern}}" %>
-          TEMPLATE
-
-          ENUMERATIONS = ERB.new(<<~TEMPLATE, trim_mode: "-")
-            <%= "\#{indent}options[:values] = [\#{casted_enumerations}]" %>
-          TEMPLATE
-
-          TRANSFORM = ERB.new(<<~TEMPLATE, trim_mode: "-")
-            <%= "\#{indent}value = \#{transform}" %>
-          TEMPLATE
-
-          def to_method_body(indent = nil)
-            [
-              value_for(ENUMERATIONS, type: :enumerations, indent: indent),
-              value_for(MIN_MAX_BOUNDS, type: :min_max_bounds, indent: indent),
-              value_for(PATTERN, type: :pattern, indent: indent),
-              value_for(TRANSFORM, type: :transform, indent: indent),
-            ].compact.join
-          end
-
-          def required_files
-            if base_class_name == :decimal
-              "require \"bigdecimal\""
-            elsif !SimpleType::SUPPORTED_DATA_TYPES.dig(base_class_name,
-                                                        :skippable)
-              "require_relative \"#{Utils.snake_case(base_class_name)}\""
-            end
-          end
-
-          private
-
-          def value_for(constant, type:, indent:)
-            return unless send("#{type}_exist?")
-
-            indent ||= "  "
-            constant.result(binding)
-          end
-
-          def min_max_bounds_exist?
-            min_bound_exist? || max_bound_exist?
-          end
-
-          def min_bound_exist?
-            Utils.present?(min_inclusive) || Utils.present?(min_exclusive)
-          end
-
-          def max_bound_exist?
-            Utils.present?(max_inclusive) || Utils.present?(max_exclusive)
-          end
-
-          def pattern_exist?
-            Utils.present?(pattern)
-          end
-
-          def enumerations_exist?
-            Utils.present?(enumerations)
-          end
-
-          def transform_exist?
-            Utils.present?(transform)
-          end
-
-          def base_class_name
-            return if Utils.blank?(base_class)
-
-            base_class.split(":").last.to_sym
-          end
-
-          def casted_enumerations
-            enumerations.map do |enumeration|
-              "super(#{enumeration.inspect})"
-            end.join(", ")
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/model/schema/xml_compiler/sequence.rb

@@ -1,52 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Model
-    module Schema
-      module XmlCompiler
-        class Sequence
-          attr_accessor :instances
-
-          XML_MAPPING_TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
-            <%= indent %>sequence do
-            <%= content -%>
-            <%= indent %>end
-          TEMPLATE
-
-          def initialize
-            @instances = []
-          end
-
-          def <<(instance)
-            return if instance.nil?
-
-            @instances << instance
-          end
-
-          def to_attributes(indent)
-            instances.filter_map do |instance|
-              instance.to_attributes(indent)
-            end.join
-          end
-
-          def to_xml_mapping(indent)
-            content = xml_block_content(indent)
-            return "" if content.empty?
-
-            XML_MAPPING_TEMPLATE.result(binding)
-          end
-
-          def required_files
-            @instances.map(&:required_files)
-          end
-
-          def xml_block_content(indent)
-            instances.filter_map do |instance|
-              instance.to_xml_mapping(indent * 2)
-            end.join
-          end
-        end
-      end
-    end
-  end
-end

data/lib/lutaml/model/schema/xml_compiler/simple_content.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module Lutaml
-  module Model
-    module Schema
-      module XmlCompiler
-        class SimpleContent
-          attr_accessor :instances, :base_class
-
-          def initialize
-            @instances = []
-            @base_class = nil
-          end
-
-          def <<(instance)
-            return if instance.nil?
-
-            @instances << instance
-          end
-
-          def to_attributes(indent = nil)
-            instances.filter_map do |instance|
-              instance.to_attributes(indent)
-            end.join("\n")
-          end
-
-          def to_xml_mapping(indent = nil)
-            instances.filter_map do |instance|
-              instance.to_xml_mapping(indent)
-            end.join("\n")
-          end
-
-          def required_files
-            instances.flat_map(&:required_files).compact.uniq
-          end
-        end
-      end
-    end
-  end
-end