lutaml-model 0.8.9 → 0.8.11

data/lib/lutaml/model/store.rb

@@ -5,9 +5,15 @@ require "weakref"
 module Lutaml
   module Model
     class Store
-      # Compact dead WeakRef shells after this many entries per class bucket.
+      # Compact dead WeakRef shells once a class bucket grows past this size.
       COMPACTION_THRESHOLD = 1000
 
+      # Once the threshold is exceeded, only compact every Nth subsequent
+      # register call. Amortises the O(N) reject! over N inserts so
+      # register stays O(1) per call rather than O(N) per call (O(N^2)
+      # cumulatively for the class).
+      COMPACTION_INTERVAL = 1000
+
       class << self
         def instance
           @instance ||= new
@@ -36,45 +42,46 @@ module Lutaml
 
       def initialize
         @store = ::Hash.new { |hash, key| hash[key] = [] }
-        # Lazy index: built on first resolve for a given (class, key) pair.
-        # Key: [class_name, reference_method] → { value => WeakRef(object) }
+        # Nested index: { model_key => { reference_key => { value => WeakRef(object) } } }
+        # Grouped by model_key so register only iterates this class's own indices.
         @index = {}
+        @inserts_since_compaction = ::Hash.new(0)
+        @compaction_count = 0
       end
 
       def register(object)
         model_key = object.class.to_s
         refs = @store[model_key]
         refs << WeakRef.new(object)
+        @inserts_since_compaction[model_key] += 1
 
-        compact_if_needed(refs)
+        compact_if_needed(refs, model_key)
 
         update_existing_indices(object, model_key)
       end
 
       def resolve(model_class, reference_key, reference_value)
         model_key = model_class.to_s
-        index_key = [model_key, reference_key]
+        model_indices = @index[model_key]
 
-        # Build index lazily on first resolve for this (class, key) pair
-        unless @index.key?(index_key)
-          ensure_index(index_key, model_key,
-                       reference_key)
+        unless model_indices&.key?(reference_key)
+          model_indices = ensure_model_index(model_key)
+          build_index(model_indices, model_key, reference_key)
         end
 
-        # O(1) indexed lookup
-        entry = @index[index_key][reference_value]
+        entry = model_indices[reference_key][reference_value]
         return nil unless entry
 
-        begin
-          entry.__getobj__ if entry.weakref_alive?
-        rescue WeakRef::RefError
-          nil
-        end
+        obj = dereference(entry)
+        model_indices[reference_key].delete(reference_value) unless obj
+        obj
       end
 
       def clear
         @store = ::Hash.new { |hash, key| hash[key] = [] }
         @index = {}
+        @inserts_since_compaction = ::Hash.new(0)
+        @compaction_count = 0
       end
 
       def store
@@ -87,11 +94,31 @@ module Lutaml
         end
       end
 
+      def refs_for(model_key)
+        @store[model_key]
+      end
+
+      def inserts_since_compaction
+        @inserts_since_compaction
+      end
+
+      def compaction_count
+        @compaction_count
+      end
+
+      def index_entry_count(model_key)
+        @index[model_key]&.sum { |_reference_key, entries| entries.size } || 0
+      end
+
       private
 
+      def ensure_model_index(model_key)
+        @index[model_key] ||= {}
+      end
+
       # Build index for a (model_class, reference_key) pair by scanning existing instances.
-      def ensure_index(index_key, model_key, reference_key)
-        entries = @index[index_key] = {}
+      def build_index(model_indices, model_key, reference_key)
+        entries = model_indices[reference_key] = {}
         @store[model_key]&.each do |ref|
           obj = ref.__getobj__
           value = obj.public_send(reference_key)
@@ -101,27 +128,53 @@ module Lutaml
         end
       end
 
-      # Update indices that already exist for this model class.
+      # Update indices that already exist for this model class only.
+      # O(K) where K = number of reference keys indexed for this class,
+      # not O(N×K) across all classes.
       def update_existing_indices(object, model_key)
-        @index.each do |index_key, entries|
-          next unless index_key[0] == model_key
+        model_indices = @index[model_key]
+        return unless model_indices
 
-          key_method = index_key[1]
-          value = object.public_send(key_method)
+        model_indices.each do |reference_key, entries|
+          value = object.public_send(reference_key)
           entries[value] = WeakRef.new(object) if value
         rescue WeakRef::RefError
           next
         end
       end
 
-      def compact_if_needed(refs)
+      def dereference(entry)
+        entry.__getobj__ if entry.weakref_alive?
+      rescue WeakRef::RefError
+        nil
+      end
+
+      def compact_if_needed(refs, model_key)
         return unless refs.size > COMPACTION_THRESHOLD
+        return unless @inserts_since_compaction[model_key] >= COMPACTION_INTERVAL
 
+        @inserts_since_compaction[model_key] = 0
+        @compaction_count += 1
         refs.reject! do |ref|
           !ref.weakref_alive?
         rescue WeakRef::RefError
           true
         end
+        prune_index(model_key)
+      end
+
+      def prune_index(model_key)
+        model_indices = @index[model_key]
+        return unless model_indices
+
+        model_indices.delete_if do |_reference_key, entries|
+          entries.delete_if do |_value, ref|
+            !ref.weakref_alive?
+          rescue WeakRef::RefError
+            true
+          end
+          entries.empty?
+        end
       end
     end
   end

data/lib/lutaml/model/transformation_registry.rb

@@ -185,7 +185,7 @@ module Lutaml
         # Build mapping OUTSIDE any lock to avoid deadlock
         # (ensure_mappings_imported! may recursively call get_or_build_mapping)
         mapping = model_class.mappings[format]
-        mapping = mapping || model_class.send(:default_mappings, format)
+        mapping = mapping || model_class.default_mappings(format)
 
         mapping.ensure_mappings_imported!(register_id)
 

data/lib/lutaml/model/type_context.rb

@@ -47,6 +47,9 @@ module Lutaml
       # @return [Array<TypeSubstitution>] Type substitution rules
       attr_reader :substitutions
 
+      # @return [Hash{Class => Class}] Pre-built Hash for O(1) substitution lookup
+      attr_reader :substitution_hash
+
       # @return [Array<TypeContext>] Fallback contexts (in order)
       attr_reader :fallback_contexts
 
@@ -60,6 +63,9 @@ module Lutaml
         @id = id.to_sym
         @registry = registry
         @substitutions = Array(substitutions).freeze
+        @substitution_hash = @substitutions.to_h do |s|
+          [s.from_type, s.to_type]
+        end.freeze
         @fallback_contexts = Array(fallback_contexts).freeze
         freeze
       end
@@ -254,7 +260,7 @@ module Lutaml
           ctx
         when Symbol, String
           # Try to look up from GlobalContext if available
-          if defined?(GlobalContext) && GlobalContext.respond_to?(:registry)
+          if defined?(GlobalContext)
             GlobalContext.registry.lookup(ctx)
           end
         end

data/lib/lutaml/model/type_resolver.rb

@@ -157,12 +157,7 @@ module Lutaml
       def self.apply_substitutions(type, context)
         return type if context.nil? || context.substitutions.empty?
 
-        context.substitutions.each do |sub|
-          substituted = sub.apply(type)
-          return substituted if substituted
-        end
-
-        type
+        context.substitution_hash[type] || type
       end
 
       # Get all available type names from context and fallbacks.

data/lib/lutaml/model/utils.rb

@@ -163,12 +163,25 @@ module Lutaml
         #   fetch_str_or_sym(hash, :key) # => "value"
         #   fetch_str_or_sym(hash, "invalid_key") # => nil
         def fetch_str_or_sym(hash, key, default = nil)
-          if hash.key?(key.to_s)
-            hash[key.to_s]
-          elsif hash.key?(key.to_sym)
-            hash[key.to_sym]
+          case key
+          when String
+            if hash.key?(key)
+              hash[key]
+            else
+              (hash.key?(key.to_sym) ? hash[key.to_sym] : default)
+            end
+          when Symbol
+            if hash.key?(key)
+              hash[key]
+            else
+              (hash.key?(key.to_s) ? hash[key.to_s] : default)
+            end
           else
-            default
+            if hash.key?(key.to_s)
+              hash[key.to_s]
+            else
+              (hash.key?(key.to_sym) ? hash[key.to_sym] : default)
+            end
           end
         end
 
@@ -183,7 +196,7 @@ module Lutaml
         end
 
         def add_singleton_method_if_not_defined(instance, method_name, &)
-          return if instance.respond_to?(method_name)
+          return if instance.singleton_class.method_defined?(method_name, false)
 
           instance.define_singleton_method(method_name, &)
         end

data/lib/lutaml/model/validation_framework.rb

@@ -38,7 +38,7 @@ module Lutaml
             next unless rule.applicable?(context)
 
             issues = rule.check(context)
-            if context.respond_to?(:add_error)
+            if context.is_a?(Validation::Context)
               issues.each { |i| context.add_error(i) }
             end
             all_issues.concat(issues)

data/lib/lutaml/model/value_transformer.rb

@@ -10,11 +10,11 @@ module Lutaml
       end
 
       def self.from(value, format)
-        new.send(:"from_#{format}", value)
+        new.public_send(:"from_#{format}", value)
       end
 
       def self.to(value, format)
-        new(value).send(:"to_#{format}")
+        new(value).public_send(:"to_#{format}")
       end
 
       def self.can_transform?(method, format)

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.9"
+    VERSION = "0.8.11"
   end
 end

data/lib/lutaml/rdf/mapping.rb

@@ -10,7 +10,7 @@ module Lutaml
         super
         @namespace_set = Lutaml::Rdf::NamespaceSet.new
         @rdf_subject = nil
-        @rdf_type = nil
+        @rdf_type = []
         @rdf_predicates = []
         @rdf_members = []
       end
@@ -24,20 +24,26 @@ module Lutaml
       end
 
       def type(value)
-        @rdf_type = value
+        @rdf_type = Array(value)
       end
 
-      def predicate(name, namespace:, to:, lang_tagged: false)
+      def predicate(name, namespace:, to:, lang_tagged: false,
+                    uri_reference: false)
         @rdf_predicates << Lutaml::Rdf::MappingRule.new(
           name,
           namespace: namespace,
           to: to,
           lang_tagged: lang_tagged,
+          uri_reference: uri_reference,
         )
       end
 
-      def members(attr_name)
-        @rdf_members << Lutaml::Rdf::MemberRule.new(attr_name)
+      def members(attr_name, predicate_name: nil, namespace: nil)
+        @rdf_members << Lutaml::Rdf::MemberRule.new(
+          attr_name,
+          predicate_name: predicate_name,
+          namespace: namespace,
+        )
       end
 
       def mappings(_register_id = nil)
@@ -57,14 +63,14 @@ module Lutaml
       end
 
       def deep_dup
-        self.class.new.tap do |new_mapping|
-          new_mapping.instance_variable_set(:@namespace_set, @namespace_set)
-          new_mapping.instance_variable_set(:@rdf_subject, @rdf_subject)
-          new_mapping.instance_variable_set(:@rdf_type, @rdf_type)
-          new_mapping.instance_variable_set(:@rdf_predicates,
-                                            @rdf_predicates.dup)
-          new_mapping.instance_variable_set(:@rdf_members, @rdf_members.dup)
-        end
+        dup
+      end
+
+      def initialize_copy(source)
+        super
+        @rdf_type = source.rdf_type.dup
+        @rdf_predicates = source.rdf_predicates.dup
+        @rdf_members = source.rdf_members.dup
       end
     end
   end

data/lib/lutaml/rdf/mapping_rule.rb

@@ -3,14 +3,31 @@
 module Lutaml
   module Rdf
     class MappingRule
-      attr_reader :predicate_name, :namespace, :to, :lang_tagged
+      attr_reader :predicate_name, :namespace, :to, :lang_tagged, :uri_reference
 
-      def initialize(predicate_name, namespace:, to:, lang_tagged: false)
+      def initialize(predicate_name, namespace:, to:, lang_tagged: false,
+                     uri_reference: false)
         validate!(predicate_name, namespace, to)
+        if lang_tagged && uri_reference
+          raise ArgumentError,
+                "lang_tagged and uri_reference are mutually exclusive"
+        end
+
         @predicate_name = predicate_name.to_s.freeze
         @namespace = namespace
         @to = to
         @lang_tagged = lang_tagged
+        @uri_reference = uri_reference
+      end
+
+      def kind
+        if uri_reference
+          :uri_reference
+        elsif lang_tagged
+          :lang_tagged
+        else
+          :plain
+        end
       end
 
       def uri

data/lib/lutaml/rdf/member_rule.rb

@@ -3,10 +3,27 @@
 module Lutaml
   module Rdf
     class MemberRule
-      attr_reader :attr_name
+      attr_reader :attr_name, :predicate_name, :namespace
+
+      def initialize(attr_name, predicate_name: nil, namespace: nil)
+        if predicate_name && !namespace
+          raise ArgumentError,
+                "namespace is required when predicate_name is provided"
+        end
 
-      def initialize(attr_name)
         @attr_name = attr_name.to_sym
+        @predicate_name = predicate_name
+        @namespace = namespace
+      end
+
+      def linked?
+        !!@predicate_name
+      end
+
+      def linked_predicate_uri
+        return nil unless linked?
+
+        @namespace[@predicate_name]
       end
     end
   end

data/lib/lutaml/rdf/transform.rb

@@ -3,22 +3,35 @@
 module Lutaml
   module Rdf
     class Transform < Lutaml::Model::Transform
-      protected
-
       def resolve_subject_uri(mapping, instance)
         mapping.rdf_subject&.call(instance)
       end
 
-      def resolve_type_uri(mapping)
-        return unless mapping.rdf_type
+      def resolve_single_type_uri(mapping, type_value)
+        mapping.namespace_set.resolve_compact_iri(type_value)
+      end
+
+      def resolve_type_uris(mapping)
+        return [] unless mapping.rdf_type.any?
+
+        mapping.rdf_type.map { |t| resolve_single_type_uri(mapping, t) }
+      end
+
+      def each_member(instance, member_rule, &)
+        collection = Array(instance.public_send(member_rule.attr_name))
+        collection.each(&)
+      end
 
-        mapping.namespace_set.resolve_compact_iri(mapping.rdf_type)
+      def member_mapping_for(member, format)
+        member.class.mappings[format]
       end
 
-      def resolve_type_compact(mapping)
-        mapping.rdf_type
+      def extract_language(value)
+        value.language_tag if value.is_a?(Lutaml::Rdf::LanguageTagged)
       end
 
+      protected
+
       def build_instance(attrs, options)
         child_register = Lutaml::Model::Register.resolve_for_child(
           model_class, lutaml_register
@@ -27,10 +40,6 @@ module Lutaml
         root_and_parent_assignment(instance, options)
         instance
       end
-
-      def extract_language(value)
-        value.language_tag if value.is_a?(Lutaml::Rdf::LanguageTagged)
-      end
     end
   end
 end