lutaml-model 0.7.3 → 0.7.5

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

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

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module XmlCompiler
+        class SimpleType
+          attr_accessor :class_name, :base_class, :instance, :unions
+
+          LUTAML_VALUE_CLASS_NAME = "Lutaml::Model::Type::Value"
+
+          SUPPORTED_DATA_TYPES = {
+            nonNegativeInteger: { skippable: false, class_name: "Lutaml::Model::Type::String", validations: { pattern: /\+?[0-9]+/ } },
+            normalizedString: { skippable: false, class_name: "Lutaml::Model::Type::String", validations: { transform: "value.gsub(/[\\r\\n\\t]/, ' ')" } },
+            positiveInteger: { skippable: false, class_name: "Lutaml::Model::Type::Integer", validations: { min_inclusive: 0 } },
+            unsignedShort: { skippable: false, class_name: "Lutaml::Model::Type::Integer", validations: { min_inclusive: 0, max_inclusive: 65535 } },
+            base64Binary: { skippable: false, class_name: "Lutaml::Model::Type::String", validations: { pattern: /\A([A-Za-z0-9+\/]+={0,2}|\s)*\z/ } },
+            unsignedLong: { skippable: false, class_name: "Lutaml::Model::Type::Integer", validations: { min_inclusive: 0, max_inclusive: 18446744073709551615 } },
+            unsignedByte: { skippable: false, class_name: "Lutaml::Model::Type::Integer", validations: { min_inclusive: 0, max_inclusive: 255 } },
+            unsignedInt: { skippable: false, class_name: "Lutaml::Model::Type::Integer", validations: { min_inclusive: 0, max_inclusive: 4294967295 } },
+            hexBinary: { skippable: false, class_name: "Lutaml::Model::Type::String", validations: { pattern: /([0-9a-fA-F]{2})*/ } },
+            language: { skippable: false, class_name: "Lutaml::Model::Type::String", validations: { pattern: /\A[a-zA-Z]{1,8}(-[a-zA-Z0-9]{1,8})*\z/ } },
+            dateTime: { skippable: true, class_name: "Lutaml::Model::Type::DateTime" },
+            boolean: { skippable: true, class_name: "Lutaml::Model::Type::Boolean" },
+            integer: { skippable: true, class_name: "Lutaml::Model::Type::Integer" },
+            decimal: { skippable: true, class_name: "Lutaml::Model::Type::Decimal" },
+            string: { skippable: true, class_name: "Lutaml::Model::Type::String" },
+            double: { skippable: true, class_name: "Lutaml::Model::Type::Float" },
+            NCName: { skippable: false, class_name: "Lutaml::Model::Type::String", validations: { pattern: /\A[a-zA-Z_][\w.-]*\z/ } },
+            anyURI: { skippable: false, class_name: "Lutaml::Model::Type::String", validations: { pattern: "\\A\#{URI::DEFAULT_PARSER.make_regexp(%w[http https ftp])}\\z" } },
+            token: { skippable: false, class_name: "Lutaml::Model::Type::String", validations: { pattern: /\A[^\t\n\f\r ]+(?: [^\t\n\f\r ]+)*\z/ } },
+            byte: { skippable: false, class_name: "Lutaml::Model::Type::Integer", validations: { min_inclusive: -128, max_inclusive: 127 } },
+            long: { skippable: false, class_name: "Lutaml::Model::Type::Decimal" },
+            int: { skippable: true, class_name: "Lutaml::Model::Type::Integer" },
+            id: { skippable: false, class_name: "Lutaml::Model::Type::String", validations: { pattern: /\A[a-zA-Z_][\w.-]*\z/ } },
+          }.freeze
+
+          INSTANCE_MODEL_TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
+            # frozen_string_literal: true
+            require "lutaml/model"
+
+            <%= "\#{required_files}\n" -%>
+            class <%= klass_name %><%= " < \#{parent_class}" if parent_class %>
+            <%= @indent %>def self.cast(value, options = {})
+            <%= extended_indent %>return if value.nil?
+
+            <%= instance&.to_method_body(extended_indent) %>
+                value = super(value, options)
+                value
+              end
+
+            <%= @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(class_name) %>)
+            <%= @indent %>end
+            end
+
+            <%= klass_name %>.register_class_with_id
+          TEMPLATE
+
+          UNION_MODEL_TEMPLATE = ERB.new(<<~TEMPLATE, trim_mode: "-")
+            # frozen_string_literal: true
+            require "lutaml/model"
+            <%= union_required_files %>
+
+            class <%= klass_name %> < <%= LUTAML_VALUE_CLASS_NAME %>
+            <%= @indent %>def self.cast(value, options = {})
+            <%= extended_indent %>return if value.nil?
+
+            <%= union_class_method_body %>
+              end
+
+            <%= @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(class_name) %>)
+            <%= @indent %>end
+            end
+
+            <%= klass_name %>.register_class_with_id
+          TEMPLATE
+
+          def initialize(name, unions = [])
+            @class_name = name
+            @unions = unions
+          end
+
+          def to_class(options: {})
+            setup_options(options)
+            template = unions&.any? ? UNION_MODEL_TEMPLATE : INSTANCE_MODEL_TEMPLATE
+            template.result(binding)
+          end
+
+          def required_files
+            files = Array(instance&.required_files)
+            files << "require_relative \"#{Utils.snake_case(parent_class)}\"" if require_parent?
+            files.join("\n")
+          end
+
+          private
+
+          def setup_options(options)
+            @indent = " " * options&.fetch(:indent, 2)
+          end
+
+          def klass_name
+            @klass_name ||= Utils.camel_case(class_name)
+          end
+
+          def require_parent?
+            return false if Utils.blank?(base_class)
+
+            !!!SUPPORTED_DATA_TYPES[base_class&.to_sym]&.dig(:skippable)
+          end
+
+          def parent_class
+            type_info = SUPPORTED_DATA_TYPES[base_class&.to_sym]
+            return type_info[:class_name] if type_info&.dig(:skippable)
+            return Utils.camel_case(base_class.to_s) if !!!type_info&.dig(:skippable) && Utils.present?(base_class)
+
+            LUTAML_VALUE_CLASS_NAME
+          end
+
+          def union_class_method_body
+            unions.map do |union|
+              "#{extended_indent}register.get_class(:#{down_union_class_name(union)}).cast(value, options)"
+            end.join(" ||\n  ")
+          end
+
+          def union_required_files
+            unions.filter_map do |union|
+              next if SUPPORTED_DATA_TYPES.dig(last_of_split(union).to_sym, :skippable)
+
+              "require_relative \"#{down_union_class_name(union)}\""
+            end.join("\n")
+          end
+
+          def down_union_class_name(union)
+            Utils.snake_case(last_of_split(union))
+          end
+
+          def last_of_split(field)
+            field&.split(":")&.last
+          end
+
+          def extended_indent
+            (@indent || "  ") * 2
+          end
+
+          class << self
+            def setup_supported_types
+              SUPPORTED_DATA_TYPES
+                .reject { |_, simple_type| simple_type[:skippable] }
+                .each_with_object({}) do |(name, simple_type), hash|
+                str_name = name.to_s
+                new(str_name).tap do |instance|
+                  instance.base_class = Utils.base_class_snake_case(simple_type[:class_name])
+                  instance.instance = setup_restriction(instance.base_class, simple_type[:validations])
+                  hash[str_name] = instance
+                end
+              end
+            end
+
+            def setup_restriction(base_class, validations)
+              return unless validations
+
+              Restriction.new.tap do |restriction|
+                restriction.base_class = base_class
+                restriction.min_inclusive = validations[:min_inclusive]
+                restriction.max_inclusive = validations[:max_inclusive]
+                restriction.pattern = validations[:pattern]
+                restriction.transform = validations[:transform]
+              end
+            end
+
+            def skippable?(type)
+              SUPPORTED_DATA_TYPES.dig(type&.to_sym, :skippable)
+            end
+          end
+        end
+      end
+    end
+  end
+end