lutaml-model 0.7.1 → 0.7.7

data/lib/lutaml/model/collection.rb

@@ -0,0 +1,212 @@
+module Lutaml
+  module Model
+    class Collection < Lutaml::Model::Serializable
+      include Enumerable
+
+      class << self
+        INHERITED_ATTRIBUTES = %i[
+          instance_type
+          instance_name
+          order_by_field
+          order_direction
+        ].freeze
+
+        def inherited(subclass)
+          super
+
+          INHERITED_ATTRIBUTES.each do |var|
+            subclass.instance_variable_set(
+              :"@#{var}",
+              instance_variable_get(:"@#{var}"),
+            )
+          end
+        end
+
+        attr_reader :instance_type,
+                    :instance_name,
+                    :order_by_field,
+                    :order_direction
+
+        def instances(name, type, &block)
+          attribute(name, type, collection: true, validations: block)
+
+          @instance_type = Lutaml::Model::Attribute.cast_type!(type)
+          @instance_name = name
+
+          define_method(:"#{name}=") do |collection|
+            self.collection = collection
+          end
+        end
+
+        def ordered(by:, order: :asc)
+          @order_by_field = by.to_sym
+          @order_direction = order
+        end
+
+        def sort_configured?
+          !!@order_by_field
+        end
+
+        def to(format, instance, options = {})
+          mappings = mappings_for(format)
+
+          if mappings.no_root? && format == :xml
+            mappings.mappings.map do |mapping|
+              serialize_for_mapping(mapping, instance, format, options)
+            end.join("\n")
+          else
+            super(format, instance, options.merge(collection: true))
+          end
+        end
+
+        def serialize_for_mapping(mapping, instance, format, options)
+          options[:tag_name] = mapping.name
+
+          attr_value = instance.public_send(mapping.to)
+          return if attr_value.nil? || attr_value.empty?
+
+          attr_value = [attr_value] unless attr_value.is_a?(Array)
+          attr_value.map { |v| v.public_send(:"to_#{format}", options) }
+        end
+
+        def as(format, instance, options = {})
+          mappings = mappings_for(format)
+          data = super
+
+          if mappings.no_root? && format != :xml && !mappings.root_mapping
+            Utils.fetch_str_or_sym(data, instance_name)
+          else
+            data
+          end
+        end
+
+        def from(format, data, options = {})
+          mappings = mappings_for(format)
+          if mappings.no_root? && format == :xml
+            tag_name = mappings.find_by_to(instance_name).name
+            data = "<#{tag_name}>#{data}</#{tag_name}>"
+          end
+
+          super(format, data, options.merge(from_collection: true))
+        end
+
+        def of(format, data, options = {})
+          mappings = mappings_for(format)
+
+          if mappings.no_root? && format != :xml && !mappings.root_mapping
+            data = { mappings.find_by_to(instance_name).name => data }
+          end
+
+          super(format, data, options.merge(from_collection: true))
+        end
+
+        def apply_mappings(data, format, options = {})
+          super(data, format, options.merge(collection: true))
+        end
+      end
+
+      attr_reader :__register
+
+      def initialize(items = [], __register: Lutaml::Model::Config.default_register)
+        super()
+
+        @__register = __register
+        items = [items].compact unless items.is_a?(Array)
+
+        register_object = Lutaml::Model::GlobalRegister.lookup(@__register)
+        type = register_object.get_class(self.class.instance_type)
+        self.collection = items.map do |item|
+          if item.is_a?(type)
+            item
+          elsif type <= Lutaml::Model::Type::Value
+            type.cast(item)
+          else
+            type.new(item)
+          end
+        end
+
+        sort_items!
+      end
+
+      def to_format(format, options = {})
+        super(format, options.merge(collection: true))
+      end
+
+      def collection
+        instance_variable_get(:"@#{self.class.instance_name}")
+      end
+
+      def collection=(collection)
+        instance_variable_set(:"@#{self.class.instance_name}", collection)
+        sort_items!
+      end
+
+      def union(other)
+        self.class.new((items + other.items).uniq)
+      end
+
+      def intersection(other)
+        self.class.new(items & other.items)
+      end
+
+      def difference(other)
+        self.class.new(items - other.items)
+      end
+
+      def each(&block)
+        collection.each(&block)
+      end
+
+      def size
+        collection.size
+      end
+
+      def first
+        collection.first
+      end
+
+      def last
+        collection.last
+      end
+
+      def <<(item)
+        push(item)
+      end
+
+      def push(item)
+        collection.push(item)
+        sort_items!
+      end
+
+      def [](index)
+        collection[index]
+      end
+
+      def []=(index, value)
+        collection[index] = value
+        sort_items!
+      end
+
+      def empty?
+        collection&.empty?
+      end
+
+      def order_defined?
+        self.class.sort_configured?
+      end
+
+      def sort_items!
+        return if collection.nil?
+        return unless order_defined?
+
+        unless collection&.one?
+          field = self.class.order_by_field
+          direction = self.class.order_direction
+
+          collection.sort_by! { |item| item.send(field) }
+          collection.reverse! if direction == :desc
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/comparable_model.rb

@@ -467,7 +467,7 @@ module Lutaml
               return format_single_value(
                 value1,
                 parent_node,
-                "#{label}#{type_info ? " (#{type_info})" : ''}",
+                "#{label}#{" (#{type_info})" if type_info}",
               )
             end
 
@@ -482,7 +482,7 @@ module Lutaml
           when ComparableModel
             format_object_attributes(value1, value2, parent_node)
           else
-            node = Tree.new("#{label}#{type_info ? " (#{type_info})" : ''}:")
+            node = Tree.new("#{label}#{" (#{type_info})" if type_info}:")
             parent_node.add_child(node)
             node.add_child(Tree.new("- #{format_value(value1)}", color: :red))
             node.add_child(Tree.new("+ #{format_value(value2)}", color: :green))
@@ -495,7 +495,7 @@ module Lutaml
         # @param label [String] The label for the value
         # @return [String] Formatted single value
         def format_single_value(value, parent_node, label, color = nil)
-          node = Tree.new("#{label}#{label.empty? ? '' : ':'}", color: color)
+          node = Tree.new("#{label}#{':' unless label.empty?}", color: color)
           parent_node.add_child(node)
 
           case value

data/lib/lutaml/model/config.rb

@@ -3,16 +3,13 @@ module Lutaml
     module Config
       extend self
 
-      # Default values are set for these so the readers are defined below
-      attr_writer :json_adapter, :yaml_adapter
-
-      attr_accessor :xml_adapter, :toml_adapter
-
-      AVAILABLE_FORMATS = %i[xml json yaml toml].freeze
+      AVAILABLE_FORMATS = %i[xml json jsonl yaml toml hash].freeze
       KEY_VALUE_FORMATS = AVAILABLE_FORMATS - %i[xml]
 
       def configure
         yield self
+
+        self
       end
 
       # This will generate the following methods
@@ -42,55 +39,87 @@ module Lutaml
       #     one of [:tomlib, :toml_rb]
       #   @example
       #     Lutaml::Model::Config.toml_adapter = :tomlib
+      #
+      # AVAILABLE_FORMATS.each do |adapter_name|
+      #   define_method(:"#{adapter_name}_adapter_type=") do |type_name|
+      #     Lutaml::Model::FormatRegistry.send(:"#{adapter_name}_adapter_type=", type_name)
+      #   end
+      # end
+
       AVAILABLE_FORMATS.each do |adapter_name|
         define_method(:"#{adapter_name}_adapter_type=") do |type_name|
-          adapter = "#{adapter_name}_adapter"
-          type = "#{type_name}_adapter"
-
-          begin
-            adapter_file = File.join(adapter, type)
-            require_relative adapter_file
-          rescue LoadError
-            raise(
-              Lutaml::Model::UnknownAdapterTypeError.new(
-                adapter_name,
-                type_name,
-              ),
-              cause: nil,
-            )
-          end
-          Moxml::Adapter.load(type_name) unless KEY_VALUE_FORMATS.include?(adapter_name)
-
-          instance_variable_set(
-            :"@#{adapter}",
-            Lutaml::Model.const_get(to_class_name(adapter))
-                         .const_get(to_class_name(type)),
-          )
+          adapter = adapter_name.to_s
+          type = normalize_type_name(type_name, adapter_name)
+          load_adapter_file(adapter, type)
+          load_moxml_adapter(type_name, adapter_name)
+          set_adapter_for(adapter_name, class_for(adapter, type))
         end
       end
 
-      # Return JSON adapter. By default StandardJsonAdapter is used
-      #
-      # @example
-      #   Lutaml::Model::Config.json_adapter
-      #   # => Lutaml::Model::YamlAdapter::StandardJsonAdapter
-      def json_adapter
-        @json_adapter || Lutaml::Model::JsonAdapter::StandardJsonAdapter
+      def adapter_for(format)
+        @adapters[format]
       end
 
-      # Return YAML adapter. By default StandardYamlAdapter is used
-      #
-      # @example
-      #   Lutaml::Model::Config.yaml_adapter
-      #   # => Lutaml::Model::YamlAdapter::StandardYamlAdapter
-      def yaml_adapter
-        @yaml_adapter || Lutaml::Model::YamlAdapter::StandardYamlAdapter
+      def set_adapter_for(format, adapter)
+        @adapters ||= {}
+        @adapters[format] = adapter
+      end
+
+      def mappings_class_for(format)
+        Lutaml::Model::FormatRegistry.mappings_class_for(format)
+      end
+
+      def transformer_for(format)
+        Lutaml::Model::FormatRegistry.transformer_for(format)
+      end
+
+      def class_for(adapter, type)
+        # TODO: Remove once HashAdapter namespace is renamed to Hash
+        adapter = "hash_adapter" if adapter == "hash"
+
+        Lutaml::Model.const_get(to_class_name(adapter))
+          .const_get(to_class_name(type))
+      end
+
+      def default_register
+        @default_register ||= :default
+      end
+
+      def default_register=(value)
+        @default_register = case value
+                            when Symbol then value
+                            when Lutaml::Model::Register then value.id
+                            else
+                              raise "Unknown register: #{value}, expected a Symbol or a Lutaml::Model::Register instance"
+                            end
       end
 
       # @api private
       def to_class_name(str)
         str.to_s.split("_").map(&:capitalize).join
       end
+
+      private
+
+      def normalize_type_name(type_name, adapter_name)
+        "#{type_name.to_s.gsub("_#{adapter_name}", '')}_adapter"
+      end
+
+      def load_adapter_file(adapter, type)
+        # TODO: Remove once HashAdapter namespace is renamed to Hash
+        adapter = "hash_adapter" if adapter == "hash"
+
+        adapter_file = File.join(adapter, type)
+        require_relative adapter_file
+      rescue LoadError
+        raise UnknownAdapterTypeError.new(adapter, type), cause: nil
+      end
+
+      def load_moxml_adapter(type_name, adapter_name)
+        return if KEY_VALUE_FORMATS.include?(adapter_name)
+
+        Moxml::Adapter.load(type_name)
+      end
     end
   end
 end

data/lib/lutaml/model/constants.rb

@@ -2,6 +2,8 @@ module Lutaml
   module Model
     module Constants
       RAW_MAPPING_KEY = "__raw_mapping".freeze
+      KEY_MAPPING_KEY = "__key_mapping".freeze
+      VALUE_MAPPING_KEY = "__value_mapping".freeze
     end
   end
 end

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

@@ -0,0 +1,29 @@
+module Lutaml
+  module Model
+    class ElementCountOutOfRangeError < Error
+      def initialize(attr_name, appearance_count, range)
+        @attr_name = attr_name
+        @appearance_count = appearance_count
+        @range = range
+
+        super()
+      end
+
+      def to_s
+        "`#{@attr_name}` expected to appear between '#{@range.min}' and '#{@range.max}' time#{times_plural(@range.max)}, but #{times_appeared}."
+      end
+
+      private
+
+      def times_appeared
+        return "never appeared" if @appearance_count&.zero?
+
+        "appeared only #{@appearance_count} time#{times_plural(@appearance_count)}"
+      end
+
+      def times_plural(count)
+        "s" if count > 1
+      end
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module Lutaml
+  module Model
+    class InvalidAttributeNameError < Error
+      def initialize(name)
+        @name = name
+
+        super()
+      end
+
+      def to_s
+        "Attribute name '#{@name}' is not allowed"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+module Lutaml
+  module Model
+    class InvalidAttributeOptionsError < Error
+      def initialize(name, invalid_opts)
+        @name = name
+        @invalid_opts = invalid_opts
+
+        super()
+      end
+
+      def to_s
+        "Invalid options given for `#{@name}` #{@invalid_opts}"
+      end
+    end
+  end
+end

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

@@ -9,11 +9,9 @@ module Lutaml
       end
 
       def to_s
-        if @min.negative?
-          "Choice lower bound `#{@min}` must be positive"
-        else
-          "Choice upper bound `#{@max}` must be positive"
-        end
+        bound_name, value = @min.negative? ? ["lower", @min] : ["upper", @max]
+
+        "Choice #{bound_name} bound `#{value}` must be positive"
       end
     end
   end

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

@@ -1,8 +1,13 @@
 module Lutaml
   module Model
     class PolymorphicError < Error
-      def initialize(value, options)
-        super("#{value.class} not in #{options[:polymorphic]}")
+      def initialize(value, options, type)
+        error = if options[:polymorphic].is_a?(Array)
+                  "#{value.class} not in #{options[:polymorphic]}"
+                else
+                  "#{value.class} is not valid sub class of #{type}"
+                end
+        super(error)
       end
     end
   end

data/lib/lutaml/model/error/register/not_registrable_class_error.rb

@@ -0,0 +1,11 @@
+module Lutaml
+  module Model
+    class Register
+      class NotRegistrableClassError < Error
+        def initialize(model_name)
+          super("`#{model_name}` must be a `Lutaml::Model::Registrable` class or module")
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/type/invalid_value_error.rb

@@ -4,14 +4,16 @@ module Lutaml
   module Model
     module Type
       class InvalidValueError < Error
-        def initialize(message)
-          @message = message
+        def initialize(value, allowed_values)
+          @value = value
+          @allowed_values = allowed_values
 
           super()
         end
 
         def to_s
-          @message
+          "`#{@value}` is invalid, must be one of the " \
+            "following #{@allowed_values.inspect}"
         end
       end
     end

data/lib/lutaml/model/error/type/max_bound_error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Type
+      class MaxBoundError < Error
+        def initialize(value, max_bound)
+          @value = value
+          @max_bound = max_bound
+
+          super()
+        end
+
+        def to_s
+          "Value #{@value} is greater than the set maximum limit #{@max_bound}"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/type/max_length_error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Type
+      class MaxLengthError < Error
+        def initialize(value, max_length)
+          @value = value
+          @max_length = max_length
+
+          super()
+        end
+
+        def to_s
+          "String \"#{@value}\" length (#{@value.length}) is greater than the maximum allowed length #{@max_length}"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/type/min_bound_error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Type
+      class MinBoundError < Error
+        def initialize(value, min_bound)
+          @value = value
+          @min_bound = min_bound
+
+          super()
+        end
+
+        def to_s
+          "Value #{@value} is less than the set minimum limit #{@min_bound}"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/type/min_length_error.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Type
+      class MinLengthError < Error
+        def initialize(value, min_length)
+          @value = value
+          @min_length = min_length
+
+          super()
+        end
+
+        def to_s
+          "String \"#{@value}\" length (#{@value.length}) is less than the minimum required length #{@min_length}"
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/error/type/pattern_not_matched_error.rb

@@ -0,0 +1,18 @@
+module Lutaml
+  module Model
+    module Type
+      class PatternNotMatchedError < Error
+        def initialize(value, pattern)
+          @pattern = pattern
+          @value = value
+
+          super()
+        end
+
+        def to_s
+          "\"#{@value}\" does not match #{@pattern.inspect}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+module Lutaml
+  module Model
+    class ValidationFailedError < Error
+      def initialize(errors)
+        super("Validation failed: #{errors.map { |e| "`#{e}`" }.join(', ')}")
+      end
+    end
+  end
+end

data/lib/lutaml/model/error.rb

@@ -11,6 +11,7 @@ require_relative "error/incorrect_mapping_argument_error"
 require_relative "error/pattern_not_matched_error"
 require_relative "error/unknown_adapter_type_error"
 require_relative "error/collection_count_out_of_range_error"
+require_relative "error/element_count_out_of_range_error"
 require_relative "error/validation_error"
 require_relative "error/type_not_enabled_error"
 require_relative "error/type_error"
@@ -18,6 +19,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/type/min_bound_error"
+require_relative "error/type/max_bound_error"
+require_relative "error/type/pattern_not_matched_error"
+require_relative "error/type/min_length_error"
+require_relative "error/type/max_length_error"
 require_relative "error/incorrect_sequence_error"
 require_relative "error/choice_upper_bound_error"
 require_relative "error/no_root_mapping_error"
@@ -27,3 +33,7 @@ require_relative "error/unknown_sequence_mapping_error"
 require_relative "error/choice_lower_bound_error"
 require_relative "error/no_root_namespace_error"
 require_relative "error/polymorphic_error"
+require_relative "error/validation_failed_error"
+require_relative "error/invalid_attribute_name_error"
+require_relative "error/invalid_attribute_options_error"
+require_relative "error/register/not_registrable_class_error"