lutaml-model 0.7.3 → 0.7.5

data/lib/lutaml/model/collection.rb

@@ -0,0 +1,194 @@
+module Lutaml
+  module Model
+    class Collection < Lutaml::Model::Serializable
+      include Enumerable
+
+      class << self
+        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_without_register(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, register: register)
+          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,11 +3,13 @@ module Lutaml
     module Config
       extend self
 
-      AVAILABLE_FORMATS = %i[xml json yaml toml hash].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
@@ -55,11 +57,12 @@ module Lutaml
       end
 
       def adapter_for(format)
-        public_send(:"#{format}_adapter")
+        @adapters[format]
       end
 
       def set_adapter_for(format, adapter)
-        public_send(:"#{format}_adapter=", adapter)
+        @adapters ||= {}
+        @adapters[format] = adapter
       end
 
       def mappings_class_for(format)
@@ -71,10 +74,27 @@ module Lutaml
       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
@@ -86,6 +106,9 @@ module Lutaml
       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

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/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"

data/lib/lutaml/model/errors.rb

@@ -0,0 +1,36 @@
+module Lutaml
+  module Model
+    class Errors
+      include Enumerable
+
+      def initialize
+        @errors = {}
+      end
+
+      def add(attr, error)
+        @errors[attr] ||= []
+        @errors[attr] << error
+      end
+
+      def empty?
+        @errors.empty?
+      end
+
+      def each(&block)
+        @errors.each(&block)
+      end
+
+      def full_messages
+        @errors.map { |attr, errors| "#{attr}: #{errors.join(', ')}" }
+      end
+
+      def messages
+        @errors.map { |_, errors| errors.join(", ") }.flatten
+      end
+
+      def to_s
+        full_messages.join("\n")
+      end
+    end
+  end
+end

data/lib/lutaml/model/format_registry.rb

@@ -15,12 +15,15 @@ module Lutaml
           ::Lutaml::Model::Serialize.register_from_format_method(format)
           ::Lutaml::Model::Serialize.register_to_format_method(format)
 
+          Lutaml::Model::Config.set_adapter_for(format, adapter_class)
+
           Lutaml::Model::Config.define_singleton_method(:"#{format}_adapter") do
-            instance_variable_get(:"@#{format}_adapter") || adapter_class
+            @adapters[format] || adapter_class
           end
 
           Lutaml::Model::Config.define_singleton_method(:"#{format}_adapter=") do |adapter_klass|
-            instance_variable_set(:"@#{format}_adapter", adapter_klass)
+            @adapters ||= {}
+            @adapters[format] = adapter_klass
           end
         end
 

data/lib/lutaml/model/global_register.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    class GlobalRegister
+      include Singleton
+
+      def initialize
+        @registers = {}
+        default_register = Lutaml::Model::Register.new(:default)
+        register(default_register)
+      end
+
+      def register(model_register)
+        @registers[model_register.id] = model_register
+      end
+
+      def lookup(id)
+        @registers[id.to_sym]
+      end
+
+      def remove(id)
+        @registers.delete(id.to_sym)
+      end
+
+      class << self
+        def register(model_register)
+          instance.register(model_register)
+        end
+
+        def lookup(id)
+          instance.lookup(id)
+        end
+
+        def remove(id)
+          instance.remove(id)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/{hash.rb → hash_adapter.rb}

@@ -7,11 +7,11 @@ module Lutaml
   end
 end
 
-require_relative "hash/standard_adapter"
-require_relative "hash/document"
-require_relative "hash/mapping"
-require_relative "hash/mapping_rule"
-require_relative "hash/transform"
+require_relative "hash_adapter/standard_adapter"
+require_relative "hash_adapter/document"
+require_relative "hash_adapter/mapping"
+require_relative "hash_adapter/mapping_rule"
+require_relative "hash_adapter/transform"
 
 Lutaml::Model::FormatRegistry.register(
   :hash,

data/lib/lutaml/model/jsonl/document.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Jsonl
+      class Document
+        def initialize(jsons = [], register: nil)
+          @jsons = jsons
+          @register = register || Lutaml::Model::Config.default_register
+        end
+      end
+    end
+  end
+end