lutaml-model 0.8.3 → 0.8.5

data/lib/lutaml/jsonld/transform.rb

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Lutaml
+  module JsonLd
+    class Transform < Lutaml::Rdf::Transform
+      def model_to_data(instance, _format, options = {})
+        mapping = extract_mapping(options)
+        return {} unless mapping
+
+        if mapping.rdf_members.any?
+          build_graph_document(mapping, instance)
+        else
+          build_resource_object(mapping, instance)
+        end
+      end
+
+      def data_to_model(data, _format, options = {})
+        mapping = extract_mapping(options)
+        return model_class.new unless mapping
+
+        hash = data.is_a?(String) ? JSON.parse(data) : data
+
+        if hash.key?("@graph") && hash["@graph"].is_a?(Array) && !hash["@graph"].empty?
+          graph_data = hash["@graph"]
+          first = graph_data.first
+          hash = first.is_a?(Hash) ? first : {}
+        end
+
+        hash = strip_jsonld_keywords(hash)
+
+        attrs = {}
+        mapping.rdf_predicates.each do |rule|
+          value = hash[rule.predicate_name]
+          next if value.nil?
+
+          attrs[rule.to] = if rule.lang_tagged && value.is_a?(Hash)
+                             flatten_language_map(value)
+                           else
+                             value
+                           end
+        end
+
+        build_instance(attrs, options)
+      end
+
+      private
+
+      def extract_mapping(options)
+        options[:mappings] || mappings_for(:jsonld, lutaml_register)
+      end
+
+      def build_graph_document(mapping, instance)
+        context = build_merged_context(mapping, instance)
+        graph = []
+
+        if mapping.rdf_subject
+          resource = build_resource_data(mapping, instance)
+          graph << resource unless resource.empty?
+        end
+
+        mapping.rdf_members.each do |member_rule|
+          collection = Array(instance.public_send(member_rule.attr_name))
+          collection.each do |member|
+            member_mapping = member.class.mappings[:jsonld]
+            next unless member_mapping
+
+            resource = build_resource_data(member_mapping, member)
+            graph << resource unless resource.empty?
+          end
+        end
+
+        { "@context" => context, "@graph" => graph }
+      end
+
+      def build_merged_context(mapping, instance)
+        context_hash = build_context_from_mapping(mapping).to_hash
+
+        mapping.rdf_members.each do |member_rule|
+          collection = Array(instance.public_send(member_rule.attr_name))
+          next if collection.empty?
+
+          member_mapping = collection.first.class.mappings[:jsonld]
+          next unless member_mapping
+
+          context_hash.merge!(build_context_from_mapping(member_mapping).to_hash)
+        end
+
+        context_hash
+      end
+
+      def build_context_from_mapping(mapping)
+        context = Context.new
+        mapping.namespace_set.each { |ns| context.prefix(ns) }
+        mapping.rdf_predicates.each do |pred|
+          if pred.lang_tagged
+            context.term(pred.predicate_name,
+                         id: pred.uri,
+                         container: :language)
+          else
+            context.term(pred.predicate_name, id: pred.uri)
+          end
+        end
+        context
+      end
+
+      def build_resource_object(mapping, instance)
+        context = build_context_from_mapping(mapping).to_hash
+        data = build_resource_data(mapping, instance)
+        { "@context" => context }.merge(data)
+      end
+
+      def build_resource_data(mapping, instance)
+        result = {}
+
+        if mapping.rdf_type
+          result["@type"] = resolve_type_compact(mapping)
+        end
+
+        if mapping.rdf_subject
+          result["@id"] = resolve_subject_uri(mapping, instance)
+        end
+
+        mapping.rdf_predicates.each do |rule|
+          value = instance.public_send(rule.to)
+          next if value.nil?
+          next if value.is_a?(String) && value.empty?
+
+          result[rule.predicate_name] = if rule.lang_tagged
+                                          build_language_map(value)
+                                        else
+                                          serialize_rdf_value(value)
+                                        end
+        end
+
+        result
+      end
+
+      def build_language_map(values)
+        case values
+        when Array
+          map = {}
+          values.each do |v|
+            lang = extract_language(v)
+            map[lang] = v.to_s if lang
+          end
+          map.empty? ? nil : map
+        else
+          lang = extract_language(values)
+          lang ? { lang => values.to_s } : values.to_s
+        end
+      end
+
+      def flatten_language_map(lang_map)
+        lang_map.values
+      end
+
+      def serialize_rdf_value(value)
+        case value
+        when Array then value.map { |v| serialize_rdf_value(v) }
+        when Integer, Float, TrueClass, FalseClass then value
+        else value.to_s
+        end
+      end
+
+      def strip_jsonld_keywords(data)
+        return data unless data.is_a?(Hash)
+
+        data.reject { |key, _| key.start_with?("@") }
+      end
+    end
+  end
+end

data/lib/lutaml/jsonld.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative "model"
+require_relative "rdf"
+
+module Lutaml
+  module JsonLd
+    autoload :Context, "#{__dir__}/jsonld/context"
+    autoload :TermDefinition, "#{__dir__}/jsonld/term_definition"
+    autoload :Transform, "#{__dir__}/jsonld/transform"
+    autoload :Adapter, "#{__dir__}/jsonld/adapter"
+  end
+end
+
+Lutaml::Model::FormatRegistry.register(
+  :jsonld,
+  mapping_class: Lutaml::Rdf::Mapping,
+  adapter_class: Lutaml::JsonLd::Adapter,
+  transformer: Lutaml::JsonLd::Transform,
+  key_value: false,
+  rdf: true,
+  error_types: ["JSON::ParserError"],
+)

data/lib/lutaml/model/attribute.rb

@@ -330,7 +330,25 @@ module Lutaml
 
       def default(register = Lutaml::Model::Config.default_register,
 instance_object = nil)
-        cast_value(default_value(register, instance_object), register)
+        if instance_object.nil?
+          @default_cache ||= {}
+          cached = @default_cache[register]
+          return cached if cached
+
+          result = cast_value(default_value(register, nil), register)
+          if immutable_value?(result)
+            @default_cache[register] = result
+          end
+          result
+        else
+          cast_value(default_value(register, instance_object), register)
+        end
+      end
+
+      def immutable_value?(value)
+        value.nil? || value.is_a?(Numeric) || value.is_a?(String) ||
+          value.is_a?(Symbol) || value == true || value == false ||
+          value.frozen?
       end
 
       def default_value(register, instance_object = nil)

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

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    class LiquidDropAlreadyRegisteredError < Error
+      def initialize(drop_class_name)
+        super("Liquid drop class '#{drop_class_name}' is already registered.")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    class OrderedContentMappingError < Error
+      def initialize(model_class)
+        @model_class = model_class
+        super()
+      end
+
+      def to_s
+        "Element-only content model (`ordered`) does not support `map_content` in #{@model_class}. " \
+          "Use `mixed_content` instead of `ordered` when you need to capture text content between elements."
+      end
+    end
+  end
+end

data/lib/lutaml/model/format_registry.rb

@@ -23,7 +23,7 @@ module Lutaml
         # @param adapter_options [Hash, nil] { available: [...], default: :name }
         def register(format, mapping_class:, adapter_class:, transformer:,
                      adapter_loader: nil, castable_type: nil, key_value: nil,
-                     error_types: nil, adapter_options: nil)
+                     rdf: nil, error_types: nil, adapter_options: nil)
           validate_registration!(format, mapping_class, transformer)
 
           registered_formats[format] = {
@@ -33,6 +33,7 @@ module Lutaml
             adapter_loader: adapter_loader,
             castable_type: castable_type,
             key_value: key_value,
+            rdf: rdf,
             error_types: error_types,
             adapter_options: adapter_options,
             registered_at: Time.now,
@@ -109,6 +110,14 @@ module Lutaml
           registered_formats.dig(format, :key_value) == true
         end
 
+        def rdf_formats
+          registered_formats.select { |_, info| info[:rdf] }.keys
+        end
+
+        def rdf?(format)
+          registered_formats.dig(format, :rdf) == true
+        end
+
         def error_types_for(format)
           registered_formats.dig(format, :error_types)
         end

data/lib/lutaml/model/global_context.rb

@@ -194,6 +194,7 @@ module Lutaml
       def clear_caches
         @resolver.clear_all_caches
         Register.clear_resolve_cache
+        Transform.clear_cache!
       end
 
       # =====================================================================

data/lib/lutaml/model/liquefiable.rb

@@ -36,7 +36,8 @@ module Lutaml
         def register_liquid_drop_class
           validate_liquid!
           if base_drop_class
-            raise "#{drop_class_name} Already exists!"
+            raise Lutaml::Model::LiquidDropAlreadyRegisteredError,
+                  drop_class_name
           end
 
           const_set(drop_class_name,
@@ -45,6 +46,14 @@ module Lutaml
                         super()
                         @object = object
                       end
+
+                      def liquefy_value(value)
+                        if value.is_a?(Array)
+                          value.map(&:to_liquid)
+                        else
+                          value.to_liquid
+                        end
+                      end
                     end)
         end
 
@@ -99,13 +108,7 @@ module Lutaml
           return if base_drop_class.method_defined?(method_name)
 
           base_drop_class.define_method(method_name) do
-            value = @object.public_send(method_name)
-
-            if value.is_a?(Array)
-              value.map(&:to_liquid)
-            else
-              value.to_liquid
-            end
+            liquefy_value(@object.public_send(method_name))
           end
         end
 
@@ -114,13 +117,7 @@ module Lutaml
 
           liquid_mappings.mappings.each do |key, method_name|
             base_drop_class.define_method(key) do
-              value = @object.public_send(method_name)
-
-              if value.is_a?(Array)
-                value.map(&:to_liquid)
-              else
-                value.to_liquid
-              end
+              liquefy_value(@object.public_send(method_name))
             end
           end
         end

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

@@ -81,6 +81,10 @@ module Lutaml
         @polymorphic_map = polymorphic_map
         @transform = transform
 
+        # Cache whether this rule needs the full deserialize chain.
+        # Over 95% of rules are "simple" (no custom method, no delegate).
+        @needs_full_deserialize = has_custom_method_for_deserialization? || !!delegate
+
         # Only calculate default_value_map if value_map is not fully provided
         if value_map.empty? || !value_map[:from] || !value_map[:to]
           # Build value_map by starting with defaults from render_nil/render_empty,
@@ -280,9 +284,13 @@ module Lutaml
       end
 
       def deserialize(model, value, attributes, mapper_class = nil)
-        handle_custom_method(model, value, mapper_class) ||
-          handle_delegate(model, value, attributes) ||
+        if @needs_full_deserialize
+          handle_custom_method(model, value, mapper_class) ||
+            handle_delegate(model, value, attributes) ||
+            handle_transform_method(model, value, attributes)
+        else
           handle_transform_method(model, value, attributes)
+        end
       end
 
       def has_custom_method_for_serialization?

data/lib/lutaml/model/mapping_hash.rb

@@ -3,7 +3,7 @@
 module Lutaml
   module Model
     class MappingHash < ::Hash
-      attr_accessor :ordered, :node
+      attr_accessor :ordered, :node, :attribute_order
 
       def initialize
         @ordered = false

data/lib/lutaml/model/serialize/format_conversion.rb

@@ -15,7 +15,12 @@ module Lutaml
         # @param block [Proc] The DSL block to evaluate
         def process_mapping(format, *_args, &)
           klass = ::Lutaml::Model::Config.mappings_class_for(format)
-          mappings[format] ||= klass.new
+          existing = mappings[format]
+          mappings[format] = if existing.nil? || !existing.is_a?(klass)
+                               klass.new
+                             else
+                               existing
+                             end
           mappings[format].instance_eval(&)
 
           if mappings[format].respond_to?(:finalize)
@@ -273,6 +278,17 @@ module Lutaml
           end
         end
 
+        # Define RDF mappings for multiple formats (Turtle, JSON-LD, etc.).
+        # Discovers RDF formats dynamically from FormatRegistry.
+        #
+        # @param block [Proc] The DSL block
+        def rdf(&block)
+          Lutaml::Model::FormatRegistry.rdf_formats.each do |format|
+            mappings[format] = Lutaml::Rdf::Mapping.new
+            mappings[format].instance_eval(&block)
+          end
+        end
+
         # Get resolved mapping for a format
         #
         # Delegates to TransformationRegistry for centralized caching

data/lib/lutaml/model/services/transformer.rb

@@ -5,6 +5,37 @@ module Lutaml
         def call(value, rule, attribute, format: nil)
           new(rule, attribute, format).call(value)
         end
+
+        private
+
+        def get_transform_static(obj, direction)
+          transform = obj&.transform
+          return nil if transform.nil? || transform.is_a?(Class)
+
+          transform.is_a?(::Hash) ? transform[direction] : transform
+        end
+
+        def apply_static(value, sources, direction, format)
+          methods = sources.filter_map do |obj|
+            get_transform_static(obj, direction)
+          end
+
+          class_transformers = sources.filter_map do |obj|
+            next unless obj&.transform.is_a?(Class) &&
+              obj.transform < Lutaml::Model::ValueTransformer
+
+            obj.transform
+          end
+
+          return value if methods.empty? && class_transformers.empty?
+
+          apply_direction = direction == :import ? :from : :to
+          result = class_transformers.reduce(value) do |v, tc|
+            tc.public_send(apply_direction, v, format)
+          end
+
+          methods.reduce(result) { |tv, m| m.call(tv) }
+        end
       end
 
       attr_reader :rule, :attribute, :format
@@ -16,46 +47,38 @@ module Lutaml
       end
 
       def call(value)
-        # Collect all class-based and hash/proc-based transformers
-        # Apply them in the correct order based on transformation_methods
-
-        # Get ordered transformation methods (already in correct precedence)
         methods = transformation_methods
 
-        # Also check for class-based transformers and add them in correct order
-        class_transformers = []
-        if instance_of?(ExportTransformer)
-          # Export order: attribute first, then rule
-          class_transformers << attribute.transform if attribute&.transform.is_a?(Class) && attribute.transform < Lutaml::Model::ValueTransformer
-          class_transformers << rule.transform if rule&.transform.is_a?(Class) && rule.transform < Lutaml::Model::ValueTransformer
-        else
-          # Import order: rule first, then attribute
-          class_transformers << rule.transform if rule&.transform.is_a?(Class) && rule.transform < Lutaml::Model::ValueTransformer
-          class_transformers << attribute.transform if attribute&.transform.is_a?(Class) && attribute.transform < Lutaml::Model::ValueTransformer
+        class_transformers = ordered_sources.filter_map do |obj|
+          next unless obj&.transform.is_a?(Class) &&
+            obj.transform < Lutaml::Model::ValueTransformer
+
+          obj.transform
         end
 
-        # Apply class transformers first, then hash/proc transformers
         result = class_transformers.reduce(value) do |v, transformer_class|
           apply_class_transformer(v, transformer_class, format)
         end
 
-        # Then apply hash/proc transformers
         methods.reduce(result) do |transformed_value, method|
           method.call(transformed_value)
         end
       end
 
       def apply_class_transformer(value, transformer_class, format)
-        if instance_of?(ExportTransformer)
+        if export_direction?
           transformer_class.to(value, format)
         else
           transformer_class.from(value, format)
         end
       end
 
+      def export_direction?
+        false
+      end
+
       def get_transform(obj, direction)
         transform = obj&.transform
-
         return nil if transform.is_a?(Class)
 
         transform.is_a?(::Hash) ? transform[direction] : transform
@@ -63,26 +86,38 @@ module Lutaml
     end
 
     class ImportTransformer < Transformer
-      # Precedene of transformations:
-      # 1. Rule transform
-      # 2. Attribute transform
+      class << self
+        def call(value, rule, attribute, format: nil)
+          apply_static(value, [rule, attribute], :import, format)
+        end
+      end
+
+      def ordered_sources
+        [rule, attribute]
+      end
+
       def transformation_methods
-        [
-          get_transform(rule, :import),
-          get_transform(attribute, :import),
-        ].compact
+        ordered_sources.filter_map { |obj| get_transform(obj, :import) }
       end
     end
 
     class ExportTransformer < Transformer
-      # Precedene of transformations (reverse order):
-      # 1. Attribute transform
-      # 2. Rule transform
+      class << self
+        def call(value, rule, attribute, format: nil)
+          apply_static(value, [attribute, rule], :export, format)
+        end
+      end
+
+      def ordered_sources
+        [attribute, rule]
+      end
+
       def transformation_methods
-        [
-          get_transform(attribute, :export),
-          get_transform(rule, :export),
-        ].compact
+        ordered_sources.filter_map { |obj| get_transform(obj, :export) }
+      end
+
+      def export_direction?
+        true
       end
     end
   end

data/lib/lutaml/model/transform.rb

@@ -3,21 +3,58 @@
 module Lutaml
   module Model
     class Transform
+      @transform_cache = {}
+
+      # Maximum number of cached Transform instances before eviction.
+      MAX_CACHE_SIZE = 256
+
       def self.data_to_model(context, data, format, options = {})
-        new(context, options[:register]).data_to_model(data, format, options)
+        register = options[:register] || Lutaml::Model::Config.default_register
+        transform = cached_transform(context, register)
+        transform.data_to_model(data, format, options)
       end
 
       def self.model_to_data(context, model, format, options = {})
         register = model.lutaml_register if model.respond_to?(:lutaml_register)
-        new(context, register).model_to_data(model, format, options)
+        register ||= Lutaml::Model::Config.default_register
+        transform = cached_transform(context, register)
+        transform.model_to_data(model, format, options)
       end
 
-      attr_reader :context, :attributes, :lutaml_register
+      def self.cached_transform(context, register)
+        @transform_cache ||= {}
+        cache_key = [context.object_id, register]
+        entry = @transform_cache[cache_key]
+        return entry if entry
+
+        evict_if_needed if @transform_cache.size >= MAX_CACHE_SIZE
+        @transform_cache[cache_key] = new(context, register)
+      end
+
+      def self.clear_cache!
+        @transform_cache&.clear
+      end
+
+      def self.cache_size
+        @transform_cache&.size || 0
+      end
+
+      def self.evict_if_needed
+        # Evict oldest half of entries when cache is full
+        keys_to_remove = @transform_cache.keys.first(@transform_cache.size / 2)
+        keys_to_remove.each { |k| @transform_cache.delete(k) }
+      end
+      private_class_method :evict_if_needed
+
+      attr_reader :context, :lutaml_register
 
       def initialize(context, register = nil)
         @context = context
         @lutaml_register = register || Lutaml::Model::Config.default_register
-        @attributes = context.attributes(lutaml_register)
+      end
+
+      def attributes
+        context.attributes(lutaml_register)
       end
 
       def model_class

data/lib/lutaml/model/uninitialized_class.rb

@@ -49,16 +49,22 @@ module Lutaml
       end
 
       def method_missing(method, *_args, &)
-        if method.end_with?("?")
-          false
-        else
-          super
-        end
+        return false if method.end_with?("?")
+
+        nil
       end
 
       def respond_to_missing?(method_name, _include_private = false)
         method_name.end_with?("?")
       end
+
+      def dup
+        self
+      end
+
+      def clone
+        self
+      end
     end
   end
 end

data/lib/lutaml/model/validation/concerns/has_issues.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    module Validation
+      # Shared severity filtering for objects that expose an `issues`
+      # collection. Included by LayerResult and Report.
+      module HasIssues
+        def errors
+          issues.select(&:error?)
+        end
+
+        def warnings
+          issues.select(&:warning?)
+        end
+
+        def infos
+          issues.select(&:info?)
+        end
+
+        def notices
+          issues.select(&:notice?)
+        end
+      end
+    end
+  end
+end