lutaml-model 0.7.3 → 0.7.5

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

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

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

@@ -4,7 +4,7 @@ require_relative "key_value_mapping_rule"
 module Lutaml
   module Model
     class KeyValueMapping < Mapping
-      attr_reader :mappings, :format
+      attr_reader :mappings, :format, :key_mappings, :value_mappings
 
       def initialize(format = nil)
         super()
@@ -12,6 +12,22 @@ module Lutaml
         @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,
@@ -76,6 +92,39 @@ 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
 
@@ -112,8 +161,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
 
@@ -126,7 +177,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
@@ -145,10 +197,18 @@ module Lutaml
         @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?)
       end
 
+      def root_mapping
+        @mappings.find(&:root_mapping?)
+      end
+
       Lutaml::Model::Config::KEY_VALUE_FORMATS.each do |format|
         define_method(:"format_#{format}?") do
           @format == 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,

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

@@ -3,6 +3,8 @@ module Lutaml
     class MappingRule
       attr_reader :name,
                   :to,
+                  :to_instance,
+                  :as_attribute,
                   :render_nil,
                   :render_default,
                   :render_empty,
@@ -44,6 +46,8 @@ module Lutaml
       def initialize(
         name,
         to:,
+        to_instance: nil,
+        as_attribute: nil,
         render_nil: false,
         render_default: false,
         render_empty: false,
@@ -61,6 +65,8 @@ module Lutaml
       )
         @name = name
         @to = to
+        @to_instance = to_instance
+        @as_attribute = as_attribute
         @render_nil = render_nil
         @render_default = render_default
         @render_empty = render_empty
@@ -212,8 +218,7 @@ module Lutaml
       def deserialize(model, value, attributes, mapper_class = nil)
         handle_custom_method(model, value, mapper_class) ||
           handle_delegate(model, value, attributes) ||
-          handle_transform_method(model, value, attributes) ||
-          assign_value(model, value)
+          handle_transform_method(model, value, attributes)
       end
 
       def has_custom_method_for_serialization?
@@ -284,7 +289,7 @@ module Lutaml
         delegate_value = model.public_send(delegate)
         return if Utils.initialized?(delegate_value) && !delegate_value.nil?
 
-        model.public_send(:"#{delegate}=", attributes[delegate].type.new)
+        model.public_send(:"#{delegate}=", attributes[delegate].type(model.register).new)
       end
 
       def handle_transform_method(model, value, attributes)

data/lib/lutaml/model/register.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    class Register
+      attr_reader :id, :models
+
+      def initialize(id)
+        @id = id
+        @models = {}
+        @global_substitutions = {}
+        @type_class_cache = {}
+      end
+
+      def register_model(klass, id: nil)
+        id ||= Utils.base_class_snake_case(klass).to_sym
+        return Lutaml::Model::Type.register(id, klass) if klass <= Lutaml::Model::Type::Value
+        raise NotRegistrableClassError.new(klass) unless klass.include?(Lutaml::Model::Registrable)
+
+        @models[id.to_sym] = klass
+        @models[klass.to_s] = klass
+      end
+
+      def resolve(klass_str)
+        @models[klass_str.to_s]
+      end
+
+      def get_class(klass_name)
+        expected_class = get_class_without_register(klass_name)
+        if !(expected_class < Lutaml::Model::Type::Value)
+          expected_class.class_variable_set(:@@register, id)
+        end
+        expected_class
+      end
+
+      def register_model_tree(klass)
+        register_model(klass)
+        if klass.include?(Lutaml::Model::Serialize)
+          register_attributes(klass.attributes)
+        end
+      end
+
+      def register_global_type_substitution(from_type:, to_type:)
+        @global_substitutions[from_type] = to_type
+      end
+
+      def register_attributes(attributes)
+        attributes.each_value do |attribute|
+          next unless attribute.unresolved_type.is_a?(Class)
+          next if built_in_type?(attribute.unresolved_type) || attribute.unresolved_type.nil?
+
+          register_model_tree(attribute.unresolved_type)
+        end
+      end
+
+      def substitutable?(klass)
+        @global_substitutions.key?(klass)
+      end
+
+      def substitute(klass)
+        @global_substitutions[klass]
+      end
+
+      def get_class_without_register(klass_name)
+        klass = extract_class_from(klass_name)
+        raise Lutaml::Model::UnknownTypeError.new(klass_name) unless klass
+
+        substitute(klass) || substitute(klass_name) || klass
+      end
+
+      private
+
+      def get_type_class(klass_name)
+        if klass_name.is_a?(String)
+          Lutaml::Model::Type.const_get(klass_name)
+        elsif klass_name.is_a?(Symbol)
+          Lutaml::Model::Type.lookup(klass_name)
+        end
+      end
+
+      def built_in_type?(type)
+        Lutaml::Model::Type::TYPE_CODES.value?(type.inspect) ||
+          Lutaml::Model::Type::TYPE_CODES.key?(type.to_s.to_sym)
+      end
+
+      def extract_class_from(klass)
+        return klass if klass.is_a?(Class)
+        return @models[klass] if @models.key?(klass)
+
+        # Check cache first
+        return @type_class_cache[klass] if @type_class_cache.key?(klass)
+
+        # If not in cache, try to get type class and cache it
+        if type_klass = get_type_class(klass)
+          @type_class_cache[klass] = type_klass
+          type_klass
+        end
+      end
+
+      def clear_type_class_cache
+        @type_class_cache.clear
+      end
+    end
+  end
+end

data/lib/lutaml/model/registrable.rb

@@ -0,0 +1,6 @@
+module Lutaml
+  module Model
+    module Registrable
+    end
+  end
+end

data/lib/lutaml/model/schema/base_schema.rb

@@ -0,0 +1,64 @@
+require_relative "generator/definitions_collection"
+# require_relative "generator/collection"
+require_relative "generator/ref"
+
+module Lutaml
+  module Model
+    module Schema
+      class BaseSchema
+        class << self
+          def generate(klass, options = {})
+            schema = new(
+              klass,
+              schema: options[:schema],
+              id: options[:id],
+              title: options[:title],
+              description: options[:description],
+            ).generate_schema_hash
+
+            format_schema(schema, options)
+          end
+        end
+
+        attr_reader :schema, :klass
+        attr_accessor :id, :title, :description
+
+        def initialize(klass, schema:, id: nil, title: nil, description: nil)
+          @schema = schema
+          @klass = klass
+          @id = id
+          @title = title
+          @description = description
+        end
+
+        def generate_schema_hash
+          {
+            "$schema" => schema,
+            "$id" => id,
+            "description" => description,
+            "$ref" => "#/$defs/#{klass.name.gsub('::', '_')}",
+            "$defs" => generate_definitions(klass),
+          }.compact
+        end
+
+        private
+
+        def polymorphic?(attr)
+          Utils.present?(attr.options[:polymorphic])
+        end
+
+        def generate_definitions(klass)
+          Generator::DefinitionsCollection.from_class(klass).to_schema
+        end
+
+        def generate_polymorphic_definitions(attr)
+          return {} unless polymorphic?(attr)
+
+          attr.options[:polymorphic].each_with_object({}) do |child, result|
+            result.merge!(generate_definitions(child))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/decorators/attribute.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Schema
+      module Decorators
+        class Attribute
+          ATTRIBUTE_TYPES = {
+            "string" => ":string",
+            "integer" => ":integer",
+            "boolean" => ":boolean",
+            "number" => ":float",
+            "object" => ":hash",
+          }.freeze
+
+          attr_reader :name, :options, :polymorphic
+          attr_accessor :type, :base_class
+
+          # @param attribute [Hash] The JSON schema attribute to be decorated.
+          def initialize(name, options)
+            @name = name
+            @options = options
+            @type = extract_type(options)
+            @polymorphic = options["oneOf"]&.map { |choice| choice["$ref"].split("/").last }
+          end
+
+          def default
+            @options["default"]
+          end
+
+          def polymorphic?
+            !!@polymorphic
+          end
+
+          def polymorphic_classes
+            return [] unless polymorphic?
+
+            @base_class.sub_classes.map do |klass|
+              klass.namespaced_name.gsub("_", "::")
+            end
+          end
+
+          def collection?
+            @options["type"] == "array"
+          end
+
+          def collection
+            return unless collection?
+
+            if @options["minItems"] && @options["maxItems"]
+              @options["minItems"]..@options["maxItems"]
+            elsif @options["minItems"]
+              @options["minItems"]..Float::INFINITY
+            elsif @options["maxItems"]
+              0..@options["maxItems"]
+            else
+              true
+            end
+          end
+
+          def choice?
+            false
+          end
+
+          private
+
+          def lutaml_type_symbol(type)
+            return ":string" if type.nil?
+
+            type = type.first if type.is_a?(Array)
+
+            return array_type(options) if type == "array"
+            return object_type(options) if type == "object"
+
+            ATTRIBUTE_TYPES[type] || ":string"
+          end
+
+          def array_type(options)
+            lutaml_type_symbol(options["items"]["type"])
+          end
+
+          def extract_type(options)
+            return extract_type(options["items"]) if options["type"] == "array"
+
+            if options["type"]
+              lutaml_type_symbol(options["type"])
+            elsif options["$ref"]
+              options["$ref"].split("/").last.gsub("_", "::")
+            else
+              ":string" # Default to string if type is not recognized
+            end
+          end
+
+          def object_type(options)
+            if options["oneOf"]
+              {
+                "polymorphic" => options["oneOf"].map do |choice|
+                  choice["$ref"].split("/").last.gsub("_", "::")
+                end,
+              }
+
+            elsif options["properties"]
+              options["properties"].map do |name, attr|
+                Attribute.new(name, attr)
+              end
+            else
+              ":hash" # Default to hash if no specific type is defined
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/schema/decorators/choices.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require_relative "attribute"
+
+module Lutaml
+  module Model
+    module Schema
+      module Decorators
+        class Choices
+          attr_reader :attributes
+
+          # Decorates a collection of choice attributes.
+          # This class is used to handle attributes that are part of a choice
+          # constraint in a JSON schema. It provides a way to access the choice
+          # attributes in a structured manner.
+          def initialize(attributes)
+            @attributes = attributes.values
+          end
+
+          def choice?
+            true
+          end
+
+          def polymorphic?
+            false
+          end
+        end
+      end
+    end
+  end
+end