lutaml-model 0.7.1 → 0.7.7

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

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class AttributeGroup
+          attr_accessor :name, :ref, :instances
+
+          def initialize(name: nil, ref: nil)
+            @name = name
+            @ref = ref
+            @instances = []
+          end
+
+          def <<(instance)
+            return if instance.nil?
+
+            @instances << instance
+          end
+
+          def to_attributes(indent)
+            resolved_instances.map { |instance| instance.to_attributes(indent) }
+          end
+
+          def to_xml_mapping(indent)
+            resolved_instances.map { |instance| instance.to_xml_mapping(indent) }
+          end
+
+          def required_files
+            resolved_instances.map(&:required_files)
+          end
+
+          private
+
+          def resolved_instances
+            return @instances unless Utils.present?(@ref)
+
+            XmlCompiler.attribute_groups[@ref]&.instances
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class Choice
+          attr_accessor :instances, :min_occurs, :max_occurs
+
+          INDENT = "  "
+
+          TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
+            <%= indent %>choice<%= block_options %> do
+            <%= instances.map { |instance| instance.to_attributes(indent + INDENT) }.join -%>
+            <%= indent %>end
+          TEMPLATE
+
+          def initialize
+            @instances = []
+          end
+
+          def <<(instance)
+            return if instance.nil?
+
+            @instances << instance
+          end
+
+          def to_attributes(indent = INDENT)
+            TEMPLATE.result(binding)
+          end
+
+          def to_xml_mapping(indent = INDENT)
+            instances.filter_map { |instance| instance.to_xml_mapping(indent) }.join
+          end
+
+          def required_files
+            @instances.map(&:required_files).flatten.compact
+          end
+
+          private
+
+          def min_option
+            "min: #{min_occurs.nil? ? 1 : min_occurs.to_i}"
+          end
+
+          def max_option
+            value = case max_occurs
+                    when "unbounded"
+                      "Float::INFINITY"
+                    when NilClass
+                      1
+                    else
+                      max_occurs.to_i
+                    end
+            ", max: #{value}"
+          end
+
+          def block_options
+            ["(", min_option, max_option, ")"].compact.join
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class ComplexContent
+          attr_accessor :restriction
+
+          def initialize(restriction = nil)
+            @restriction = restriction
+          end
+
+          def to_attributes(indent)
+            restriction&.to_attributes(indent)
+          end
+
+          def to_xml_mapping(indent)
+            restriction&.to_xml_mapping(indent)
+          end
+
+          def required_files
+            restriction&.required_files
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class ComplexContentRestriction
+          attr_accessor :base, :instances
+
+          def initialize(base: nil, instances: [])
+            @base = base
+            @instances = instances
+          end
+
+          def <<(instance)
+            return if instance.nil?
+
+            @instances << instance
+          end
+
+          def to_attributes(indent)
+            instances.map { |instance| instance.to_attributes(indent) }
+          end
+
+          def to_xml_mapping(indent)
+            instances.map { |instance| instance.to_xml_mapping(indent) }
+          end
+
+          def required_files
+            instances.map(&:required_files)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,136 @@
+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 %>
+            <%= simple_content.to_attributes(@indent) if simple_content? -%>
+          TEMPLATE
+
+          TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
+            # frozen_string_literal: true
+
+            <%= required_files.uniq.join("\n") + "\n" -%>
+            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 %>root "<%= name %>"<%= root_options %>
+            <%= 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
+
+            <%= @indent %>def self.register
+            <%= extended_indent %>Lutaml::Model::GlobalRegister.lookup(Lutaml::Model::Config.default_register)
+            <%= @indent %>end
+
+            <%= @indent %>def self.register_class_with_id
+            <%= extended_indent %>register.register_model(self, id: :<%= Utils.snake_case(name) %>)
+            <%= @indent %>end
+            end
+
+            <%= Utils.camel_case(name) %>.register_class_with_id
+          TEMPLATE
+
+          def initialize(base_class: SERIALIZABLE_BASE_CLASS)
+            @base_class = base_class
+            @instances = []
+          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 = [base_class_require]
+            files.concat(@instances.map(&:required_files).flatten.compact.uniq)
+            files.concat(simple_content.required_files) if simple_content?
+            files
+          end
+
+          private
+
+          def setup_options(options)
+            @namespace, @prefix = options.values_at(:namespace, :prefix)
+            @indent = " " * options&.fetch(:indent, 2)
+          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 root_options
+            return "" unless mixed
+
+            ", mixed: true"
+          end
+
+          def namespace_and_prefix
+            return "" if Utils.blank?(@namespace) && Utils.blank?(@prefix)
+
+            [namespace_option, @prefix&.inspect].compact.join(", ")
+          end
+
+          def extended_indent
+            @indent * 2
+          end
+
+          def namespace_option
+            "#{extended_indent}namespace #{@namespace.inspect}"
+          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 base_class_require
+            case base_class
+            when SERIALIZABLE_BASE_CLASS
+              "require \"lutaml/model\""
+            else
+              "require_relative \"#{Utils.snake_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

@@ -0,0 +1,104 @@
+# 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_default_option}\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 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

@@ -0,0 +1,97 @@
+# 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
+
+            <%=  "\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::GlobalRegister.lookup(Lutaml::Model::Config.default_register)
+            <%= @indent %>end
+
+            <%= @indent %>def self.register_class_with_id
+            <%= extended_indent %>register.register_model(self, id: :<%= Utils.snake_case(base_name) %>)
+            <%= @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 %>no_root
+            <%= instance&.to_xml_mapping(extended_indent) -%>
+            <%= @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
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,101 @@
+# 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 { |enumeration| "super(#{enumeration.inspect})" }.join(", ")
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# 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 { |instance| instance.to_attributes(indent) }.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
+
+          private
+
+          def xml_block_content(indent)
+            instances.filter_map { |instance| instance.to_xml_mapping(indent * 2) }.join
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+# 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 { |instance| instance.to_attributes(indent) }.join("\n")
+          end
+
+          def to_xml_mapping(indent = nil)
+            instances.filter_map { |instance| instance.to_xml_mapping(indent) }.join("\n")
+          end
+
+          def required_files
+            instances.map(&:required_files).flatten.compact.uniq
+          end
+        end
+      end
+    end
+  end
+end