lutaml-model 0.5.3 → 0.6.0

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."
@@ -235,6 +256,8 @@ module Lutaml
           end
         elsif type <= Serialize && value.is_a?(Hash)
           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/constants.rb

@@ -0,0 +1,7 @@
+module Lutaml
+  module Model
+    module Constants
+      RAW_MAPPING_KEY = "__raw_mapping".freeze
+    end
+  end
+end

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/type/invalid_value_error.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Type
+      class InvalidValueError < Error
+        def initialize(message)
+          @message = message
+
+          super()
+        end
+
+        def to_s
+          @message
+        end
+      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

@@ -16,3 +16,12 @@ require_relative "error/type_error"
 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,11 +32,33 @@ module Lutaml
           delegate: delegate,
           child_mappings: child_mappings,
           root_mappings: root_mappings,
+          transform: transform,
         )
       end
 
       alias map_element map
 
+      def map_all(
+        to: nil,
+        render_nil: false,
+        render_default: false,
+        with: {},
+        delegate: nil
+      )
+        @raw_mapping = true
+        validate!(Constants::RAW_MAPPING_KEY, to, with)
+        @mappings << KeyValueMappingRule.new(
+          Constants::RAW_MAPPING_KEY,
+          to: to,
+          render_nil: render_nil,
+          render_default: render_default,
+          with: with,
+          delegate: delegate,
+        )
+      end
+
+      alias map_all_content map_all
+
       def name_for_mapping(root_mappings, name)
         return "root_mapping" if root_mappings
 
@@ -43,12 +66,14 @@ module Lutaml
       end
 
       def validate!(key, to, with)
-        if to.nil? && with.empty?
+        validate_mappings!(key)
+
+        if to.nil? && with.empty? && !@raw_mapping
           msg = ":to or :with argument is required for mapping '#{key}'"
           raise IncorrectMappingArgumentsError.new(msg)
         end
 
-        if !with.empty? && (with[:from].nil? || with[:to].nil?)
+        if !with.empty? && (with[:from].nil? || with[:to].nil?) && !@raw_mapping
           msg = ":with argument for mapping '#{key}' requires :to and :from keys"
           raise IncorrectMappingArgumentsError.new(msg)
         end
@@ -62,6 +87,12 @@ module Lutaml
         end
       end
 
+      def validate_mappings!(_type)
+        if (@raw_mapping && Utils.present?(@mappings)) || (!@raw_mapping && @mappings.any?(&:raw_mapping?))
+          raise StandardError, "map_all is not allowed with other mappings"
+        end
+      end
+
       def deep_dup
         self.class.new.tap do |new_mapping|
           new_mapping.instance_variable_set(:@mappings, duplicate_mappings)

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)
@@ -36,6 +36,14 @@ module Lutaml
         key?("#cdata-section") || key?("text")
       end
 
+      def assign_or_append_value(key, value)
+        self[key] = if self[key]
+                      [self[key], value].flatten
+                    else
+                      value
+                    end
+      end
+
       def ordered?
         @ordered
       end

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
@@ -84,6 +89,18 @@ module Lutaml
         name.is_a?(Array)
       end
 
+      def raw_mapping?
+        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