lutaml-model 0.7.1 → 0.7.2

data/lib/lutaml/model/format_registry.rb

@@ -0,0 +1,41 @@
+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.define_singleton_method(:"#{format}_adapter") do
+            instance_variable_get(:"@#{format}_adapter") || adapter_class
+          end
+
+          Lutaml::Model::Config.define_singleton_method(:"#{format}_adapter=") do |adapter_klass|
+            instance_variable_set(:"@#{format}_adapter", 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/hash/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/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/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/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/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.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module HashAdapter
+    end
+  end
+end
+
+require_relative "hash/standard_adapter"
+require_relative "hash/document"
+require_relative "hash/mapping"
+require_relative "hash/mapping_rule"
+require_relative "hash/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/key_value_document.rb

@@ -0,0 +1,27 @@
+module Lutaml
+  module Model
+    class KeyValueDocument
+      attr_reader :attributes
+
+      def initialize(attributes = {})
+        @attributes = attributes
+      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,12 +1,14 @@
+require_relative "mapping"
 require_relative "key_value_mapping_rule"
 
 module Lutaml
   module Model
-    class KeyValueMapping
+    class KeyValueMapping < Mapping
       attr_reader :mappings, :format
 
       def initialize(format = nil)
-        @mappings = []
+        super()
+
         @format = format
       end
 
@@ -96,10 +98,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",

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

@@ -0,0 +1,13 @@
+module Lutaml
+  module Model
+    class Mapping
+      def initialize
+        @mappings = []
+      end
+
+      def mappings
+        raise NotImplementedError, "#{self.class.name} must implement `mappings`."
+      end
+    end
+  end
+end

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

@@ -216,8 +216,12 @@ module Lutaml
           assign_value(model, value)
       end
 
-      def using_custom_methods?
-        !custom_methods.empty?
+      def has_custom_method_for_serialization?
+        !custom_methods.empty? && custom_methods[:to]
+      end
+
+      def has_custom_method_for_deserialization?
+        !custom_methods.empty? && custom_methods[:from]
       end
 
       def multiple_mappings?
@@ -284,10 +288,7 @@ module Lutaml
       end
 
       def handle_transform_method(model, value, attributes)
-        transform_method = transform[:import] || attributes[to].transform_import_method
-        return unless transform_method
-
-        assign_value(model, transform_method.call(value))
+        assign_value(model, ImportTransformer.call(value, self, attributes[to]))
         true
       end
 

data/lib/lutaml/model/serialization_adapter.rb

@@ -0,0 +1,22 @@
+module Lutaml
+  module Model
+    class SerializationAdapter
+      def self.handles_format(format)
+        # Lutaml::Model::Config.register_format(format, self)
+        @handles = format
+      end
+
+      def self.document_class(klass = nil)
+        if klass
+          @document_class = klass
+        else
+          @document_class
+        end
+      end
+
+      def self.parse(data, _options = {})
+        document_class.parse(data, create_additions: false)
+      end
+    end
+  end
+end