lutaml-model 0.5.4 → 0.6.1

data/lib/lutaml/model/attribute.rb

@@ -10,6 +10,9 @@ module Lutaml
         collection
         values
         pattern
+        transform
+        choice
+        sequence
       ].freeze
 
       def initialize(name, type, options = {})
@@ -33,6 +36,10 @@ module Lutaml
         @options[:delegate]
       end
 
+      def transform
+        @options[:transform] || {}
+      end
+
       def cast_type!(type)
         case type
         when Symbol
@@ -81,15 +88,17 @@ module Lutaml
       end
 
       def default
-        value = if delegate
-                  type.attributes[to].default
-                elsif options[:default].is_a?(Proc)
-                  options[:default].call
-                else
-                  options[:default]
-                end
-
-        cast_value(value)
+        cast_value(default_value)
+      end
+
+      def default_value
+        if delegate
+          type.attributes[to].default
+        elsif options[:default].is_a?(Proc)
+          options[:default].call
+        else
+          options[:default]
+        end
       end
 
       def pattern
@@ -100,8 +109,16 @@ module Lutaml
         @options.key?(:values) ? @options[:values] : []
       end
 
+      def transform_import_method
+        transform[:import]
+      end
+
+      def transform_export_method
+        transform[:export]
+      end
+
       def valid_value!(value)
-        return true if value.nil? && !collection?
+        return true if value.nil? && singular?
         return true unless enum?
 
         unless valid_value?(value)
@@ -153,6 +170,10 @@ module Lutaml
           raise ArgumentError, "Invalid collection range: #{range}"
         end
 
+        validate_range!(range)
+      end
+
+      def validate_range!(range)
         if range.begin.nil?
           raise ArgumentError,
                 "Invalid collection range: #{range}. Begin must be specified."
@@ -227,14 +248,15 @@ module Lutaml
       end
 
       def cast(value, format, options = {})
-        value ||= [] if collection?
+        return value if type <= Serialize && value.is_a?(type.model)
 
+        value ||= [] if collection?
         if value.is_a?(Array)
-          value.map do |v|
-            cast(v, format, options)
-          end
-        elsif type <= Serialize && value.is_a?(Hash)
+          value.map { |v| cast(v, format, options) }
+        elsif type <= Serialize && (value.is_a?(Hash) || value.is_a?(Lutaml::Model::XmlAdapter::XmlElement))
           type.apply_mappings(value, format, options)
+        elsif !value.nil? && !value.is_a?(type)
+          type.send(:"from_#{format}", value)
         else
           type.cast(value)
         end

data/lib/lutaml/model/choice.rb

@@ -0,0 +1,56 @@
+module Lutaml
+  module Model
+    class Choice
+      attr_reader :attributes,
+                  :model,
+                  :min,
+                  :max
+
+      def initialize(model, min, max)
+        @attributes = []
+        @model = model
+        @min = min
+        @max = max
+
+        raise Lutaml::Model::InvalidChoiceRangeError.new(@min, @max) if @min.negative? || @max.negative?
+      end
+
+      def attribute(name, type, options = {})
+        options[:choice] = self
+        @attributes << @model.attribute(name, type, options)
+      end
+
+      def choice(min: 1, max: 1, &block)
+        @attributes << Choice.new(@model, min, max).tap do |c|
+          c.instance_eval(&block)
+        end
+      end
+
+      def validate_content!(object)
+        validated_attributes = []
+        valid = valid_attributes(object, validated_attributes)
+
+        raise Lutaml::Model::ChoiceUpperBoundError.new(validated_attributes, @max) if valid.count > @max
+        raise Lutaml::Model::ChoiceLowerBoundError.new(validated_attributes, @min) if valid.count < @min
+      end
+
+      private
+
+      def valid_attributes(object, validated_attributes)
+        @attributes.each do |attribute|
+          if attribute.is_a?(Choice)
+            begin
+              attribute.validate_content!(object)
+              validated_attributes << attribute
+            rescue Lutaml::Model::ChoiceLowerBoundError
+            end
+          elsif Utils.present?(object.public_send(attribute.name))
+            validated_attributes << attribute.name
+          end
+        end
+
+        validated_attributes
+      end
+    end
+  end
+end

data/lib/lutaml/model/config.rb

@@ -59,6 +59,7 @@ module Lutaml
               cause: nil,
             )
           end
+          Moxml::Adapter.load(type_name) unless KEY_VALUE_FORMATS.include?(adapter_name)
 
           instance_variable_set(
             :"@#{adapter}",

data/lib/lutaml/model/error/choice_lower_bound_error.rb

@@ -0,0 +1,9 @@
+module Lutaml
+  module Model
+    class ChoiceLowerBoundError < Error
+      def initialize(validated_attributes, min)
+        super("Attributes `#{validated_attributes}` count is less than the lower bound `#{min}`")
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/choice_upper_bound_error.rb

@@ -0,0 +1,9 @@
+module Lutaml
+  module Model
+    class ChoiceUpperBoundError < Error
+      def initialize(validated_attributes, max)
+        super("Attributes `#{validated_attributes}` count exceeds the upper bound `#{max}`")
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/import_model_with_root_error.rb

@@ -0,0 +1,9 @@
+module Lutaml
+  module Model
+    class ImportModelWithRootError < Error
+      def initialize(model)
+        super("Cannot import a model `#{model}` with a root element")
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/incorrect_sequence_error.rb

@@ -0,0 +1,9 @@
+module Lutaml
+  module Model
+    class IncorrectSequenceError < Error
+      def initialize(defined_order_element, expected_order_element)
+        super("Element `#{expected_order_element}` does not match the expected sequence order element `#{defined_order_element}`")
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/invalid_choice_range_error.rb

@@ -0,0 +1,20 @@
+module Lutaml
+  module Model
+    class InvalidChoiceRangeError < Error
+      def initialize(min, max)
+        @min = min
+        @max = max
+
+        super()
+      end
+
+      def to_s
+        if @min.negative?
+          "Choice lower bound `#{@min}` must be positive"
+        else
+          "Choice upper bound `#{@max}` must be positive"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/no_root_mapping_error.rb

@@ -0,0 +1,9 @@
+module Lutaml
+  module Model
+    class NoRootMappingError < Error
+      def initialize(model)
+        super("#{model} has `no_root`, it allowed only for reusable models")
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/no_root_namespace_error.rb

@@ -0,0 +1,9 @@
+module Lutaml
+  module Model
+    class NoRootNamespaceError < Error
+      def to_s
+        "Cannot assign namespace to `no_root`"
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/unknown_sequence_mapping_error.rb

@@ -0,0 +1,9 @@
+module Lutaml
+  module Model
+    class UnknownSequenceMappingError < Error
+      def initialize(method_name)
+        super("#{method_name} is not allowed in sequence")
+      end
+    end
+  end
+end

data/lib/lutaml/model/error.rb

@@ -17,3 +17,11 @@ require_relative "error/unknown_type_error"
 require_relative "error/multiple_mappings_error"
 require_relative "error/collection_true_missing_error"
 require_relative "error/type/invalid_value_error"
+require_relative "error/incorrect_sequence_error"
+require_relative "error/choice_upper_bound_error"
+require_relative "error/no_root_mapping_error"
+require_relative "error/import_model_with_root_error"
+require_relative "error/invalid_choice_range_error"
+require_relative "error/unknown_sequence_mapping_error"
+require_relative "error/choice_lower_bound_error"
+require_relative "error/no_root_namespace_error"

data/lib/lutaml/model/json_adapter/standard_json_adapter.rb

@@ -10,7 +10,12 @@ module Lutaml
         end
 
         def to_json(*args)
-          JSON.generate(@attributes, *args)
+          options = args.first || {}
+          if options[:pretty]
+            JSON.pretty_generate(@attributes, *args)
+          else
+            JSON.generate(@attributes, *args)
+          end
         end
       end
     end

data/lib/lutaml/model/key_value_mapping.rb

@@ -17,7 +17,8 @@ module Lutaml
         with: {},
         delegate: nil,
         child_mappings: nil,
-        root_mappings: nil
+        root_mappings: nil,
+        transform: {}
       )
         mapping_name = name_for_mapping(root_mappings, name)
         validate!(mapping_name, to, with)
@@ -31,6 +32,7 @@ module Lutaml
           delegate: delegate,
           child_mappings: child_mappings,
           root_mappings: root_mappings,
+          transform: transform,
         )
       end
 

data/lib/lutaml/model/key_value_mapping_rule.rb

@@ -14,7 +14,8 @@ module Lutaml
         with: {},
         delegate: nil,
         child_mappings: nil,
-        root_mappings: nil
+        root_mappings: nil,
+        transform: {}
       )
         super(
           name,
@@ -22,7 +23,8 @@ module Lutaml
           render_nil: render_nil,
           render_default: render_default,
           with: with,
-          delegate: delegate
+          delegate: delegate,
+          transform: transform
         )
 
         @child_mappings = child_mappings

data/lib/lutaml/model/liquefiable.rb

@@ -0,0 +1,59 @@
+require "liquid"
+
+module Lutaml
+  module Model
+    module Liquefiable
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      module ClassMethods
+        def register_liquid_drop_class
+          if drop_class
+            raise "#{drop_class_name} Already exists!"
+          end
+
+          const_set(drop_class_name,
+                    Class.new(Liquid::Drop) do
+                      def initialize(object)
+                        super()
+                        @object = object
+                      end
+                    end)
+        end
+
+        def drop_class_name
+          @drop_class_name ||= if name
+                                 "#{to_s.split('::').last}Drop"
+                               else
+                                 "Drop"
+                               end
+        end
+
+        def drop_class
+          const_get(drop_class_name)
+        rescue StandardError
+          nil
+        end
+
+        def register_drop_method(method_name)
+          register_liquid_drop_class unless drop_class
+
+          drop_class.define_method(method_name) do
+            value = @object.public_send(method_name)
+
+            if value.is_a?(Array)
+              value.map(&:to_liquid)
+            else
+              value.to_liquid
+            end
+          end
+        end
+      end
+
+      def to_liquid
+        self.class.drop_class.new(self)
+      end
+    end
+  end
+end

data/lib/lutaml/model/mapping_hash.rb

@@ -11,7 +11,7 @@ module Lutaml
       end
 
       def item_order
-        @item_order&.map { |key| normalize(key) } || keys
+        @item_order
       end
 
       def fetch(key)

data/lib/lutaml/model/mapping_rule.rb

@@ -7,7 +7,8 @@ module Lutaml
                   :render_default,
                   :attribute,
                   :custom_methods,
-                  :delegate
+                  :delegate,
+                  :transform
 
       def initialize(
         name,
@@ -17,7 +18,8 @@ module Lutaml
         with: {},
         attribute: false,
         delegate: nil,
-        root_mappings: nil
+        root_mappings: nil,
+        transform: {}
       )
         @name = name
         @to = to
@@ -27,6 +29,7 @@ module Lutaml
         @attribute = attribute
         @delegate = delegate
         @root_mappings = root_mappings
+        @transform = transform
       end
 
       alias from name
@@ -71,6 +74,8 @@ module Lutaml
           end
 
           model.public_send(delegate).public_send(:"#{to}=", value)
+        elsif transform_method = transform[:import] || attributes[to].transform_import_method
+          model.public_send(:"#{to}=", transform_method.call(value))
         else
           model.public_send(:"#{to}=", value)
         end
@@ -88,6 +93,14 @@ module Lutaml
         name == Constants::RAW_MAPPING_KEY
       end
 
+      def eql?(other)
+        other.class == self.class &&
+          instance_variables.all? do |var|
+            instance_variable_get(var) == other.instance_variable_get(var)
+          end
+      end
+      alias == eql?
+
       def deep_dup
         raise NotImplementedError, "Subclasses must implement `deep_dup`."
       end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "erb"
+require "tmpdir"
 require "lutaml/xsd"
 require_relative "templates/simple_type"
 
@@ -37,7 +38,7 @@ module Lutaml
             if content&.key_exist?(:sequence) || content&.key_exist?(:choice) || content&.key_exist?(:group)
               output = resolve_content(content).map do |element_name, element|
                 element = @elements[element.ref_class.split(":")&.last] if element&.key_exist?(:ref_class)
-                "  attribute :\#{Utils.snake_case(element_name)}, \#{Utils.camel_case(element.type_name.split(":").last)}\#{resolve_occurs(element.arguments) if element.key_exist?(:arguments)}"
+                "  attribute :\#{Utils.snake_case(element_name)}, \#{resolve_element_class(element)}\#{resolve_occurs(element.arguments) if element.key_exist?(:arguments)}"
               end.join("\n")
               output + "\n" if output && !output&.empty?
             end
@@ -49,13 +50,13 @@ module Lutaml
                   element.map { |attribute| "  attribute :\#{Utils.snake_case(attribute.name)}, \#{resolve_attribute_class(attribute)}\#{resolve_attribute_default(attribute.default) if attribute.key_exist?(:default)}" }.join("\n")
                 else
                   element = @elements[element.ref_class.split(":")&.last] if element&.key_exist?(:ref_class)
-                  "  attribute :\#{Utils.snake_case(element_name)}, \#{Utils.camel_case(element.type_name.split(":").last)}\#{resolve_occurs(element.arguments) if element.key_exist?(:arguments)}"
+                  "  attribute :\#{Utils.snake_case(element_name)}, \#{resolve_element_class(element)}\#{resolve_occurs(element.arguments) if element.key_exist?(:arguments)}"
                 end
               end.join("\n")
               output + "\n" if output && !output&.empty?
             end
           -%>
-          <%= "  attribute :content, \#{content.simple_content.extension_base}" if content_exist = content.key_exist?(:simple_content) && content.simple_content.key_exist?(:extension_base) -%>
+          <%= "  attribute :content, \#{content[:mixed] ? ':string' : content.simple_content.extension_base}" if content_exist = (content.key_exist?(:simple_content) && content.simple_content.key_exist?(:extension_base)) || content[:mixed] -%>
 
             xml do
               root "<%= name %>", mixed: true
@@ -107,13 +108,28 @@ module Lutaml
 
         def to_models(schema, options = {})
           as_models(schema, options: options)
-          dir = options.fetch(:output_dir, "lutaml_models_#{Time.now.to_i}")
-          FileUtils.mkdir_p(dir)
-
           @data_types_classes = Templates::SimpleType.create_simple_types(@simple_types)
-          @data_types_classes.each { |name, content| create_file(name, content, dir) }
-          @complex_types.each { |name, content| create_file(name, MODEL_TEMPLATE.result(binding), dir) }
-          nil
+          if options[:create_files]
+            dir = options.fetch(:output_dir, "lutaml_models_#{Time.now.to_i}")
+            FileUtils.mkdir_p(dir)
+            @data_types_classes.each do |name, content|
+              create_file(name, content, dir)
+            end
+            @complex_types.each do |name, content|
+              create_file(name, MODEL_TEMPLATE.result(binding), dir)
+            end
+            nil
+          else
+            simple_types = @data_types_classes.transform_keys do |key|
+              Utils.camel_case(key.to_s)
+            end
+            complex_types = @complex_types.to_h do |name, content|
+              [Utils.camel_case(name), MODEL_TEMPLATE.result(binding)]
+            end
+            classes_hash = simple_types.merge(complex_types)
+            require_classes(classes_hash) if options[:load_classes]
+            classes_hash
+          end
         end
 
         private
@@ -122,6 +138,15 @@ module Lutaml
           File.write("#{dir}/#{Utils.snake_case(name)}.rb", content)
         end
 
+        def require_classes(classes_hash)
+          Dir.mktmpdir do |dir|
+            classes_hash.each do |name, klass|
+              create_file(name, klass, dir)
+              require "#{dir}/#{Utils.snake_case(name)}"
+            end
+          end
+        end
+
         # START: STRUCTURE SETUP METHODS
 
         def as_models(schema, options: {})
@@ -136,7 +161,7 @@ module Lutaml
           @complex_types = MappingHash.new
           @attribute_groups = MappingHash.new
 
-          schema_to_models([parsed_schema])
+          schema_to_models(Array(parsed_schema))
         end
 
         def schema_to_models(schemas)
@@ -196,6 +221,7 @@ module Lutaml
           MappingHash.new.tap do |hash|
             hash[:attributes] = [] if complex_type.attribute.any?
             hash[:attribute_groups] = [] if complex_type.attribute_group.any?
+            hash[:mixed] = complex_type.mixed
             resolved_element_order(complex_type).each do |element|
               case element
               when Xsd::Attribute
@@ -237,18 +263,18 @@ module Lutaml
                 hash[:sequences] << setup_sequence(instance)
               when Xsd::Element
                 hash[:elements] << if instance.name
-                                     setup_element(instance)
-                                   else
-                                     create_mapping_hash(instance.ref, hash_key: :ref_class)
-                                   end
+                  setup_element(instance)
+                else
+                  create_mapping_hash(instance.ref, hash_key: :ref_class)
+                end
               when Xsd::Choice
                 hash[:choice] << setup_choice(instance)
               when Xsd::Group
                 hash[:groups] << if instance.name
-                                   setup_group_type(instance)
-                                 else
-                                   create_mapping_hash(instance.ref, hash_key: :ref_class)
-                                 end
+                  setup_group_type(instance)
+                else
+                  create_mapping_hash(instance.ref, hash_key: :ref_class)
+                end
               when Xsd::Any
                 # No implementation yet!
               end
@@ -363,7 +389,7 @@ module Lutaml
         def restriction_patterns(patterns, hash)
           return if patterns.empty?
 
-          hash[:pattern] = patterns.map { |pattern| "(#{pattern.value})" }.join("|")
+          hash[:pattern] = patterns.map { |p| "(#{p.value})" }.join("|")
           hash
         end
 
@@ -404,22 +430,23 @@ module Lutaml
           end
         end
 
-        def resolved_element_order(object, ignore_text: true)
+        def resolved_element_order(object)
           return [] if object.element_order.nil?
 
-          object.element_order.each_with_object(object.element_order.dup) do |name, array|
-            next array.delete(name) if name == "text" && (ignore_text || !object.respond_to?(:text))
-            next array.delete(name) if ELEMENT_ORDER_IGNORABLE.include?(name)
+          object.element_order.each_with_object(object.element_order.dup) do |builder_instance, array|
+            next array.delete(builder_instance) if builder_instance.text?
+            next array.delete(builder_instance) if ELEMENT_ORDER_IGNORABLE.include?(builder_instance.name)
 
             index = 0
             array.each_with_index do |element, i|
-              next unless element == name
+              next unless element == builder_instance
 
-              array[i] = Array(object.send(Utils.snake_case(name)))[index]
+              array[i] = Array(object.send(Utils.snake_case(builder_instance.name)))[index]
               index += 1
             end
           end
         end
+
         # END: STRUCTURE SETUP METHODS
 
         # START: TEMPLATE RESOLVER METHODS
@@ -439,6 +466,16 @@ module Lutaml
           end
         end
 
+        def resolve_element_class(element)
+          element_class = element.type_name.split(":").last
+          case element_class
+          when *DEFAULT_CLASSES
+            ":#{element_class}"
+          else
+            Utils.camel_case(element_class)
+          end
+        end
+
         def resolve_occurs(arguments)
           min_occurs = arguments[:min_occurs]
           max_occurs = arguments[:max_occurs]
@@ -583,6 +620,7 @@ module Lutaml
           end
           @required_files.uniq.sort_by(&:length)
         end
+
         # END: TEMPLATE RESOLVER METHODS
 
         # START: REQUIRED FILES LIST COMPILER METHODS
@@ -710,9 +748,13 @@ module Lutaml
         def required_files_elements(elements)
           elements.each do |element|
             element = @elements[element.ref_class.split(":").last] if element.key_exist?(:ref_class)
-            @required_files << Utils.snake_case(element.type_name.split(":").last)
+            element_class = element.type_name.split(":").last
+            next if DEFAULT_CLASSES.include?(element_class)
+
+            @required_files << Utils.snake_case(element_class)
           end
         end
+
         # END: REQUIRED FILES LIST COMPILER METHODS
       end
     end

data/lib/lutaml/model/schema_location.rb

@@ -11,6 +11,13 @@ module Lutaml
       def to_xml_attribute
         "#{@namespace} #{@location}".strip
       end
+
+      def eql?(other)
+        other.class == self.class &&
+          namespace == other.namespace &&
+          location == other.location
+      end
+      alias == eql?
     end
 
     class SchemaLocation