lutaml-model 0.7.1 → 0.7.7

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

@@ -0,0 +1,44 @@
+module Lutaml
+  module Model
+    class FormatRegistry
+      class << self
+        attr_reader :format, :mapping_class, :adapter_class
+
+        def register(format, mapping_class:, adapter_class:, transformer:)
+          registered_formats[format] = {
+            mapping_class: mapping_class,
+            transformer: transformer,
+          }
+
+          ::Lutaml::Model::Type::Value.register_format_to_from_methods(format)
+          ::Lutaml::Model::Serialize.register_format_mapping_method(format)
+          ::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
+            @adapters[format] || adapter_class
+          end
+
+          Lutaml::Model::Config.define_singleton_method(:"#{format}_adapter=") do |adapter_klass|
+            @adapters ||= {}
+            @adapters[format] = adapter_klass
+          end
+        end
+
+        def mappings_class_for(format)
+          registered_formats.dig(format, :mapping_class)
+        end
+
+        def transformer_for(format)
+          registered_formats.dig(format, :transformer)
+        end
+
+        def registered_formats
+          @registered_formats ||= {}
+        end
+      end
+    end
+  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_adapter/document.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module HashAdapter
+      # Base class for Hash documents
+      class Document < KeyValueDocument
+      end
+    end
+  end
+end

data/lib/lutaml/model/hash_adapter/mapping.rb

@@ -0,0 +1,19 @@
+require_relative "../mapping/key_value_mapping"
+
+module Lutaml
+  module Model
+    module HashAdapter
+      class Mapping < Lutaml::Model::KeyValueMapping
+        def initialize
+          super(:hash)
+        end
+
+        def deep_dup
+          self.class.new.tap do |new_mapping|
+            new_mapping.instance_variable_set(:@mappings, duplicate_mappings)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/hash_adapter/mapping_rule.rb

@@ -0,0 +1,9 @@
+require_relative "../mapping/key_value_mapping_rule"
+
+module Lutaml
+  module Model
+    module HashAdapter
+      class MappingRule < Lutaml::Model::KeyValueMappingRule; end
+    end
+  end
+end

data/lib/lutaml/model/hash_adapter/standard_adapter.rb

@@ -0,0 +1,17 @@
+require_relative "document"
+
+module Lutaml
+  module Model
+    module HashAdapter
+      class StandardAdapter < Document
+        def self.parse(hsh, _options = {})
+          hsh
+        end
+
+        def to_hash(_options = {})
+          @attributes
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/hash_adapter/transform.rb

@@ -0,0 +1,8 @@
+module Lutaml
+  module Model
+    module HashAdapter
+      class Transform < Lutaml::Model::KeyValueTransform
+      end
+    end
+  end
+end

data/lib/lutaml/model/hash_adapter.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module HashAdapter
+    end
+  end
+end
+
+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,
+  mapping_class: Lutaml::Model::HashAdapter::Mapping,
+  adapter_class: Lutaml::Model::HashAdapter::StandardAdapter,
+  transformer: Lutaml::Model::HashAdapter::Transform,
+)

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Json
+      # Base class for JSON documents
+      class Document < Lutaml::Model::KeyValueDocument
+      end
+    end
+  end
+end

data/lib/lutaml/model/json/mapping.rb

@@ -0,0 +1,19 @@
+require_relative "../mapping/key_value_mapping"
+
+module Lutaml
+  module Model
+    module Json
+      class Mapping < Lutaml::Model::KeyValueMapping
+        def initialize
+          super(:json)
+        end
+
+        def deep_dup
+          self.class.new.tap do |new_mapping|
+            new_mapping.instance_variable_set(:@mappings, duplicate_mappings)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/json/mapping_rule.rb

@@ -0,0 +1,9 @@
+require_relative "../mapping/key_value_mapping_rule"
+
+module Lutaml
+  module Model
+    module Json
+      class MappingRule < Lutaml::Model::KeyValueMappingRule; end
+    end
+  end
+end

data/lib/lutaml/model/{json_adapter → json}/multi_json_adapter.rb

@@ -1,13 +1,12 @@
 require "multi_json"
-require_relative "json_document"
+require_relative "document"
 
 module Lutaml
   module Model
-    module JsonAdapter
-      class MultiJsonAdapter < JsonDocument
+    module Json
+      class MultiJsonAdapter < Document
         def self.parse(json, _options = {})
-          data = MultiJson.load(json)
-          new(data)
+          MultiJson.load(json)
         end
 
         def to_json(*args)

data/lib/lutaml/model/{json_adapter/standard_json_adapter.rb → json/standard_adapter.rb}

@@ -1,10 +1,12 @@
 require "json"
-require_relative "json_document"
+require_relative "document"
 
 module Lutaml
   module Model
-    module JsonAdapter
-      class StandardJsonAdapter < JsonDocument
+    module Json
+      class StandardAdapter < Document
+        FORMAT_SYMBOL = :json
+
         def self.parse(json, _options = {})
           JSON.parse(json, create_additions: false)
         end

data/lib/lutaml/model/json/transform.rb

@@ -0,0 +1,8 @@
+module Lutaml
+  module Model
+    module Json
+      class Transform < Lutaml::Model::KeyValueTransform
+      end
+    end
+  end
+end

data/lib/lutaml/model/json.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Json
+    end
+  end
+end
+
+require_relative "json/standard_adapter"
+require_relative "json/document"
+require_relative "json/mapping"
+require_relative "json/mapping_rule"
+require_relative "json/transform"
+
+Lutaml::Model::FormatRegistry.register(
+  :json,
+  mapping_class: Lutaml::Model::Json::Mapping,
+  adapter_class: Lutaml::Model::Json::StandardAdapter,
+  transformer: Lutaml::Model::Json::Transform,
+)

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

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

@@ -0,0 +1,19 @@
+require_relative "../mapping/key_value_mapping"
+
+module Lutaml
+  module Model
+    module Jsonl
+      class Mapping < Lutaml::Model::KeyValueMapping
+        def initialize
+          super(:jsonl)
+        end
+
+        def deep_dup
+          self.class.new.tap do |new_mapping|
+            new_mapping.instance_variable_set(:@mappings, duplicate_mappings)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,9 @@
+require_relative "../mapping/key_value_mapping_rule"
+
+module Lutaml
+  module Model
+    module Jsonl
+      class MappingRule < Lutaml::Model::KeyValueMappingRule; end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require "json"
+require_relative "document"
+
+module Lutaml
+  module Model
+    module Jsonl
+      class StandardAdapter < Document
+        FORMAT_SYMBOL = :jsonl
+
+        def self.parse(jsonl, _options = {})
+          results = []
+          jsonl.split("\n").each do |line|
+            next if line.strip.empty?
+
+            begin
+              results << JSON.parse(line, create_additions: false)
+            rescue JSON::ParserError => e
+              warn "Skipping invalid line: #{e.message}"
+            end
+          end
+
+          results
+        end
+
+        def to_jsonl(*_args)
+          @jsons.map do |json|
+            JSON.generate(json)
+          end.join("\n")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Lutaml
+  module Model
+    module Jsonl
+      class Transform < Lutaml::Model::KeyValueTransform
+        def data_to_model(data, format, options = {})
+          mappings = defined_mappings_for(:jsonl) || mappings_for(:json)
+
+          super(data, format, options.merge(mappings: mappings))
+        end
+
+        def model_to_data(instance, format, options = {})
+          mappings = defined_mappings_for(:jsonl) || mappings_for(:json)
+
+          super(instance, format, options.merge(mappings: mappings))
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/jsonl.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Jsonl
+    end
+  end
+end
+
+require_relative "jsonl/standard_adapter"
+require_relative "jsonl/document"
+require_relative "jsonl/mapping"
+require_relative "jsonl/mapping_rule"
+require_relative "jsonl/transform"
+
+Lutaml::Model::FormatRegistry.register(
+  :jsonl,
+  mapping_class: Lutaml::Model::Jsonl::Mapping,
+  adapter_class: Lutaml::Model::Jsonl::StandardAdapter,
+  transformer: Lutaml::Model::Jsonl::Transform,
+)

data/lib/lutaml/model/key_value_document.rb

@@ -0,0 +1,28 @@
+module Lutaml
+  module Model
+    class KeyValueDocument
+      attr_reader :attributes, :register
+
+      def initialize(attributes = {}, register: nil)
+        @attributes = attributes
+        @register = register || Lutaml::Model::Config.default_register
+      end
+
+      def [](key)
+        @attributes[key]
+      end
+
+      def []=(key, value)
+        @attributes[key] = value
+      end
+
+      def key?(key)
+        @attributes.key?(key)
+      end
+
+      def to_h
+        @attributes
+      end
+    end
+  end
+end

data/lib/lutaml/model/mapping/key_value_mapping.rb

@@ -1,15 +1,33 @@
+require_relative "mapping"
 require_relative "key_value_mapping_rule"
 
 module Lutaml
   module Model
-    class KeyValueMapping
-      attr_reader :mappings, :format
+    class KeyValueMapping < Mapping
+      attr_reader :format, :key_mappings, :value_mappings
 
       def initialize(format = nil)
-        @mappings = []
+        super()
+        @mappings = {}
         @format = format
       end
 
+      def root(name = nil)
+        @root = name
+      end
+
+      def no_root
+        @root = nil
+      end
+
+      def no_root?
+        @root.nil?
+      end
+
+      def root_name
+        @root
+      end
+
       def map(
         name = nil,
         to: nil,
@@ -31,7 +49,7 @@ module Lutaml
         mapping_name = name_for_mapping(root_mappings, name)
         validate!(mapping_name, to, with, render_nil, render_empty)
 
-        @mappings << KeyValueMappingRule.new(
+        @mappings[mapping_name] = KeyValueMappingRule.new(
           mapping_name,
           to: to,
           render_nil: render_nil,
@@ -62,7 +80,7 @@ module Lutaml
       )
         @raw_mapping = true
         validate!(Constants::RAW_MAPPING_KEY, to, with, render_nil, nil)
-        @mappings << KeyValueMappingRule.new(
+        @mappings[Constants::RAW_MAPPING_KEY] = KeyValueMappingRule.new(
           Constants::RAW_MAPPING_KEY,
           to: to,
           render_nil: render_nil,
@@ -74,12 +92,53 @@ module Lutaml
 
       alias map_all_content map_all
 
+      def map_instances(to:)
+        map(root_name || to, to: to)
+      end
+
+      def map_key(to_instance: nil, as_attribute: nil)
+        @key_mappings = KeyValueMappingRule.new(
+          Constants::KEY_MAPPING_KEY,
+          to: nil,
+          to_instance: to_instance,
+          as_attribute: as_attribute,
+        )
+      end
+
+      def map_value(to_instance: nil, as_attribute: nil)
+        @value_mappings = KeyValueMappingRule.new(
+          Constants::VALUE_MAPPING_KEY,
+          to: nil,
+          to_instance: to_instance,
+          as_attribute: as_attribute,
+        )
+      end
+
+      def key_value_mappings
+        {
+          key: @key_mappings,
+          value: @value_mappings,
+        }.compact
+      end
+
+      def key_value_mappings?
+        Utils.present?(@key_mappings) || Utils.present?(@value_mappings)
+      end
+
       def name_for_mapping(root_mappings, name)
         return "root_mapping" if root_mappings
 
         name
       end
 
+      def mappings
+        @mappings.values
+      end
+
+      def mappings_hash
+        @mappings
+      end
+
       def validate!(key, to, with, render_nil, render_empty)
         validate_mappings!(key)
         validate_to_and_with_arguments!(key, to, with)
@@ -96,10 +155,12 @@ module Lutaml
           )
         end
 
-        validate_with_options!(key, with)
+        validate_with_options!(to, key, with)
       end
 
-      def validate_with_options!(key, with)
+      def validate_with_options!(to, key, with)
+        return true if to
+
         if !with.empty? && (with[:from].nil? || with[:to].nil?) && !@raw_mapping
           raise IncorrectMappingArgumentsError.new(
             ":with argument for mapping '#{key}' requires :to and :from keys",
@@ -108,8 +169,10 @@ module Lutaml
       end
 
       def validate_root_mappings!(name)
-        if @mappings.any?(&:root_mapping?) || (name == "root_mapping" && @mappings.any?)
-          raise MultipleMappingsError.new("root_mappings cannot be used with other mappings")
+        if root_mapping || (name == "root_mapping" && @mappings.any?)
+          raise MultipleMappingsError.new(
+            "root_mappings cannot be used with other mappings",
+          )
         end
       end
 
@@ -122,7 +185,8 @@ module Lutaml
       end
 
       def validate_mappings!(_type)
-        if (@raw_mapping && Utils.present?(@mappings)) || (!@raw_mapping && @mappings.any?(&:raw_mapping?))
+        if (@raw_mapping && Utils.present?(@mappings)) ||
+            (!@raw_mapping && mappings.any?(&:raw_mapping?))
           raise StandardError, "map_all is not allowed with other mappings"
         end
       end
@@ -134,15 +198,23 @@ module Lutaml
       end
 
       def duplicate_mappings
-        @mappings.map(&:deep_dup)
+        Utils.deep_dup(@mappings)
       end
 
       def find_by_to(to)
-        @mappings.find { |m| m.to.to_s == to.to_s }
+        mappings.find { |m| m.to.to_s == to.to_s }
+      end
+
+      def find_by_name(name)
+        @mappings.find { |m| m.name.to_s == name.to_s }
       end
 
       def polymorphic_mapping
-        @mappings.find(&:polymorphic_mapping?)
+        mappings.find(&:polymorphic_mapping?)
+      end
+
+      def root_mapping
+        mappings.find(&:root_mapping?)
       end
 
       Lutaml::Model::Config::KEY_VALUE_FORMATS.each do |format|

data/lib/lutaml/model/mapping/key_value_mapping_rule.rb

@@ -9,6 +9,8 @@ module Lutaml
       def initialize(
         name,
         to:,
+        to_instance: nil,
+        as_attribute: nil,
         render_nil: false,
         render_default: false,
         render_empty: false,
@@ -27,6 +29,8 @@ module Lutaml
         super(
           name,
           to: to,
+          to_instance: to_instance,
+          as_attribute: as_attribute,
           render_nil: render_nil,
           render_default: render_default,
           render_empty: render_empty,
@@ -60,6 +64,7 @@ module Lutaml
           with: Utils.deep_dup(custom_methods),
           delegate: delegate,
           child_mappings: Utils.deep_dup(child_mappings),
+          root_mappings: Utils.deep_dup(root_mappings),
           value_map: Utils.deep_dup(@value_map),
         )
       end