jpie 3.10.1 → 3.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aee1da20dd3c81baafa8bcb78801d128f2b59f76be85b12216f96bf35b822344
-  data.tar.gz: 7de107c0fd9ea459ad0f7015d7b0a6877e88462f81b9900cdf022d14788a8118
+  metadata.gz: 3cc59c786e140082618fccd88462e9ea9e3c98d97aa6184752d9d06b0c99d8eb
+  data.tar.gz: 4e212599caf45aad70ba6f286a2be35e5d61df0aee6c62e23f3177f827e7bb83
 SHA512:
-  metadata.gz: 6639e6a66ac7c37cbf50372b433f9b1be772d6e1bda28cd76edbfb4a15612c6307bb9412894e0c6eede135aa6e0de321c2726cf3eda493381f746153ff6dd4fc
-  data.tar.gz: 1998a903147f3737344b172459656dbb2638525d0371aac16c6951a8c519334ee4ddae641a7a260d200cd41d1c4ea480202bfd476bb930a1f55a8165d1ce4a07
+  metadata.gz: 2360e7d99ce16c2e9a9b485920811cd56f69e6281cd2dfd5b565be44a23c6cea9f9b85f8bd23caabe45b8e8976ff67e650d43bdc3a49ca9de1aab75151dc33db
+  data.tar.gz: 29f4244ee319f9a68403f4aeda3f8a497b843c5b67e0cd975704bc5e3f9ac0c4041da86fc008c618ca4552c08b3f167eb6794ae36adc7ad4b14095ec6e3bc7b9

data/CHANGELOG.md

@@ -7,6 +7,34 @@ at release time.
 
 ## [Unreleased]
 
+## [3.11.0]
+
+### Changed
+
+- Read a model-backed attribute with `has_attribute?` and `read_attribute`.
+  The serializer called `ActiveRecord#attributes` three times per attribute per
+  record, and each call builds a hash of every column. A record with a fat text
+  column paid for that column on all three.
+- Drop the per-record objects in the include walk. Each visited record
+  allocated a struct, a hash copy of the path context, and an empty keyword
+  hash; the attachment verdict now lifts out of the loop. The relationship
+  names an include path asks for are computed once per path, not once per
+  record.
+- Precompute each include path's walk once per request. The walk re-split and
+  re-joined the path strings at every level for every parent record.
+- Look a relationship definition up through a name-keyed index. The linear
+  scan converted every entry's name on every lookup, once per record per hop.
+- Memoize the ActiveStorage attachment verdict per class and name. The
+  reflection lookup allocated a string per call, per relationship per record.
+- Resolve a model's resource class and type name through identity-keyed front
+  caches. The name-keyed caches allocated their key strings on every call.
+- Serialize a record through one resource instance. The attribute reader and
+  the meta reader each built their own, so a resource's memoized reads ran
+  twice.
+- Skip the respond_to? probe on a loaded singular association target. The
+  probe walked ActiveModel's attribute matcher and allocated a string per
+  record.
+
 ## [3.10.1]
 
 ### Fixed

data/lib/json_api/active_storage/detection.rb

@@ -1,17 +1,35 @@
 # frozen_string_literal: true
 
+require "concurrent/map"
+
 module JSONAPI
   module ActiveStorage
     module Detection
+      # The reflection lookup allocates a string per call, and the serializer
+      # asks per relationship per record. The verdict is a function of the
+      # class object and the name, so memoize it. Keys are class objects: the
+      # railtie clears the cache on code reload so a reloaded class cannot be
+      # retained.
+      @attachment_cache = Concurrent::Map.new
+
       module_function
 
       def attachment?(association_name, model_class)
         return false unless defined?(::ActiveStorage)
 
-        model_class.respond_to?(:reflect_on_attachment) &&
+        cache = @attachment_cache.compute_if_absent(model_class) { Concurrent::Map.new }
+        cached = cache[association_name.to_sym]
+        return cached unless cached.nil?
+
+        cache[association_name.to_sym] =
+          model_class.respond_to?(:reflect_on_attachment) &&
           model_class.reflect_on_attachment(association_name.to_sym).present?
       end
 
+      def reset_cache!
+        @attachment_cache.clear
+      end
+
       def blob_type?(type)
         return false unless defined?(::ActiveStorage)
 

data/lib/json_api/railtie.rb

@@ -105,8 +105,8 @@ module JSONAPI
       # that pre-populate ResourceLoader caches in their own to_prepare blocks
       # run after this and re-apply their entries.
       app.reloader.to_prepare do
-        JSONAPI::ResourceLoader.reset_cache!
-        JSONAPI::TypeConversion.reset_cache!
+        [JSONAPI::ResourceLoader, JSONAPI::TypeConversion,
+         JSONAPI::ActiveStorage::Detection,].each(&:reset_cache!)
         Railtie.setup_base_controllers
       end
 

data/lib/json_api/resources/concerns/relationships_dsl.rb

@@ -31,6 +31,7 @@ module JSONAPI
 
         def reset_relationship_definitions!
           remove_instance_variable(:@relationship_definitions) if defined?(@relationship_definitions)
+          remove_instance_variable(:@relationship_definition_index) if defined?(@relationship_definition_index)
         end
 
         def relationship_names
@@ -39,6 +40,20 @@ module JSONAPI
       end
 
       module RelationshipHelperMethods
+        # Name-keyed lookup over relationship_definitions. The serializer asks
+        # for one definition by name once per record per hop; a linear scan
+        # with a to_s per entry allocated thousands of strings per request.
+        # Both spellings key the same entry, so a lookup converts nothing.
+        def relationship_definition_index
+          return @relationship_definition_index if defined?(@relationship_definition_index)
+
+          index = relationship_definitions.each_with_object({}) do |r, h|
+            h[r[:name]] = r
+            h[r[:name].to_s] = r
+          end
+          @relationship_definition_index = index.freeze
+        end
+
         def register_relationship(name:, type:, meta:, options:)
           @relationships ||= []
           @relationships << { name: name.to_sym, type:, meta:, options: }

data/lib/json_api/resources/resource_loader.rb

@@ -25,10 +25,17 @@ module JSONAPI
     # caches on code reload.
     @find_cache = Concurrent::Map.new
     @model_cache = Concurrent::Map.new
+    # Identity front cache for find_for_model: the string cache key allocated
+    # on every call, and the serializer calls per record and per identifier.
+    # Nested by fallback flag and namespace so a configuration flip cannot
+    # serve a stale class. Values come through the string-keyed path, so an
+    # application that pre-populates @model_cache keeps its pins.
+    @model_identity_cache = Concurrent::Map.new
 
     def self.reset_cache!
       @find_cache.clear
       @model_cache.clear
+      @model_identity_cache.clear
     end
 
     def self.find(resource_type, namespace: nil)
@@ -59,6 +66,18 @@ module JSONAPI
     def self.find_for_model(model_class, namespace: nil)
       return ActiveStorageBlobResource if active_storage_blob?(model_class)
 
+      bucket = model_identity_bucket(namespace)
+      bucket[model_class] || (bucket[model_class] = find_for_model_uncached(model_class, namespace))
+    end
+
+    def self.model_identity_bucket(namespace)
+      fallback = @model_identity_cache.compute_if_absent(JSONAPI.configuration.namespace_fallback ? 1 : 0) do
+        Concurrent::Map.new
+      end
+      fallback.compute_if_absent(namespace) { Concurrent::Map.new }
+    end
+
+    def self.find_for_model_uncached(model_class, namespace)
       key = model_cache_key(model_class, namespace)
       cached = @model_cache[key]
       return cached if cached

data/lib/json_api/serialization/concerns/attributes_serialization.rb

@@ -20,9 +20,8 @@ module JSONAPI
       end
 
       def build_attributes_hash
-        permitted_attrs = definition.permitted_attributes.map(&:to_sym)
+        permitted_attrs = definition.permitted_attributes
         attributes = {}
-        definition_instance = definition.new(record, {})
 
         permitted_attrs.each do |attr_sym|
           attributes[attr_sym] = get_attribute_value(definition_instance, attr_sym)
@@ -34,16 +33,22 @@ module JSONAPI
       def get_attribute_value(definition_instance, attr_sym)
         return definition_instance.public_send(attr_sym) if definition_instance.respond_to?(attr_sym, false)
 
-        attr_name = attr_sym.to_s
-        return record.attributes[attr_name] if model_has_attribute?(attr_name)
-
-        nil
+        read_model_attribute(attr_sym.to_s)
       end
 
-      def model_has_attribute?(attr_name)
-        record.respond_to?(:attributes) &&
-          record.attributes.is_a?(Hash) &&
-          record.attributes.key?(attr_name)
+      # ActiveRecord#attributes builds a hash of every column on every call,
+      # and this reader called it three times per attribute per record: twice
+      # to ask whether the column exists, once to read it. A record with a fat
+      # text column paid for that column on all three. has_attribute? and
+      # read_attribute answer from the attribute set itself, one attribute at a
+      # time. A model that is not ActiveRecord keeps the hash route.
+      def read_model_attribute(attr_name)
+        if record.respond_to?(:has_attribute?) && record.respond_to?(:read_attribute)
+          return record.has_attribute?(attr_name) ? record.read_attribute(attr_name) : nil
+        end
+
+        attributes = record.attributes if record.respond_to?(:attributes)
+        attributes.is_a?(Hash) ? attributes[attr_name] : nil
       end
     end
   end

data/lib/json_api/serialization/concerns/include_filtering.rb

@@ -10,7 +10,15 @@ module JSONAPI
       # denies. The request-scoped cache memoizes the scopes and the per-id
       # verdicts, so each record is vetted at most once per request.
       def filter_loaded_records(association, related_klass)
-        loaded_array = association.target.respond_to?(:to_a) ? association.target.to_a : Array(association.target)
+        target = association.target
+        # A collection target is an Array; a singular target is the record or
+        # nil. A respond_to?(:to_a) probe on a record walks ActiveModel's
+        # attribute matcher and allocates a string per probe.
+        loaded_array = if target.is_a?(Array)
+                         target
+                       else
+                         target.nil? ? [] : [target]
+                       end
         return [] if loaded_array.empty?
 
         include_filter_cache.filter(loaded_array, related_klass)

data/lib/json_api/serialization/concerns/includes_serialization.rb

@@ -4,10 +4,19 @@ require_relative "include_filtering"
 
 module JSONAPI
   module Serialization
-    IncludeContext = Struct.new(:fields, :included_records, :processed, :all_includes, keyword_init: true)
-    PathContext = Struct.new(:path_parts, :path_to_related, :association_name, :current_record, keyword_init: true)
-    IncludeIteration = Struct.new(:related_record, :path_parts, :path_to_related, :association_name, :current_record,
-                                  keyword_init: true,)
+    IncludeContext = Struct.new(:fields, :included_records, :processed, :all_includes, :requested, :walks,
+                                keyword_init: true,) do
+      # Per-request memos: the relationship names each include path asks for,
+      # and the precomputed walk for each path. They default lazily, so a
+      # context built by hand (a caller outside this gem) works without
+      # naming them.
+      def requested = self[:requested] ||= {}
+
+      def walks = self[:walks] ||= {}
+    end
+    # Precomputed shape of one include path: association symbols per depth and
+    # the dotted prefix string that names each depth from the root.
+    IncludePathWalk = Struct.new(:names, :prefixes, keyword_init: true)
 
     module IncludesSerialization
       include IncludePathHelpers
@@ -19,7 +28,7 @@ module JSONAPI
 
         ctx = context || build_include_context(fields, all_includes)
         ctx.all_includes ||= all_includes
-        all_includes.each { |path| serialize_include_path(record, path, ctx, path_from_root: "") }
+        all_includes.each { |path| serialize_include_path(record, path_walk_for(path, ctx), 0, ctx) }
         ctx.included_records
       end
 
@@ -29,34 +38,45 @@ module JSONAPI
 
       private
 
-      def serialize_include_path(current_record, include_path, ctx, path_from_root: "")
-        path_parts = include_path.split(".")
-        association_name = path_parts.first.to_sym
+      # The split, the association symbols, and the prefix strings depend on
+      # the path alone, so compute them once per path instead of once per
+      # parent record. The old walk re-split and re-joined the path strings at
+      # every level for every record it passed.
+      def path_walk_for(path, ctx)
+        ctx.walks[path] ||= begin
+          names = path.split(".").map(&:to_sym)
+          prefixes = names.each_with_index.map { |_, i| names[0..i].join(".") }
+          IncludePathWalk.new(names: names, prefixes: prefixes)
+        end
+      end
+
+      def serialize_include_path(current_record, walk, depth, ctx)
+        association_name = walk.names[depth]
         return unless valid_include_association?(current_record, association_name)
 
-        path_to_related = path_from_root.blank? ? path_parts.first : "#{path_from_root}.#{path_parts.first}"
-        path_ctx = PathContext.new(path_parts:, path_to_related:, association_name:, current_record: current_record)
-        process_related_records(get_related_records(current_record, association_name), path_ctx, ctx)
+        serialize_walk_level(current_record, get_related_records(current_record, association_name),
+                             walk, depth, ctx,)
       end
 
-      def process_related_records(related_array, path_ctx, ctx)
+      # The attachment verdict holds for the whole related array: it reads the
+      # association name and the parent class, which do not change inside the
+      # loop.
+      def serialize_walk_level(current_record, related_array, walk, depth, ctx)
+        attachment = self.class.active_storage_attachment?(walk.names[depth], current_record.class)
+        nested = depth + 1 < walk.names.size
+
         related_array.each do |related_record|
-          iter = IncludeIteration.new(related_record: related_record, **path_ctx.to_h)
-          serialize_related_record(iter, ctx)
+          serialize_walk_record(related_record, current_record, walk, depth, ctx, attachment: attachment)
+          serialize_include_path(related_record, walk, depth + 1, ctx) if nested
         end
       end
 
-      def serialize_related_record(iter, ctx)
-        parent_context = parent_context_for(iter.association_name, iter.current_record)
-        serialize_and_process_record(iter.related_record, iter.path_to_related, ctx, **parent_context)
-        serialize_nested_path(iter.related_record, iter.path_parts, iter.path_to_related, ctx)
-      end
-
-      def parent_context_for(association_name, current_record)
-        if self.class.active_storage_attachment?(association_name, current_record.class)
-          { parent_record: current_record, association_name: }
+      def serialize_walk_record(related_record, current_record, walk, depth, ctx, attachment:)
+        if attachment
+          serialize_and_process_record(related_record, walk.prefixes[depth], ctx,
+                                       parent_record: current_record, association_name: walk.names[depth],)
         else
-          {}
+          serialize_and_process_record(related_record, walk.prefixes[depth], ctx)
         end
       end
 
@@ -122,12 +142,12 @@ module JSONAPI
       end
 
       def serialize_and_process_record(related_record, path_to_record, ctx, parent_record: nil, association_name: nil)
-        return if ctx.processed.include?(build_record_key(related_record))
+        return unless ctx.processed.add?(build_record_key(related_record))
 
-        requested = include_paths_to_relationship_names(ctx.all_includes, path_to_record)
+        requested = ctx.requested[path_to_record] ||=
+          include_paths_to_relationship_names(ctx.all_includes, path_to_record)
         serializer = child_serializer(related_record, parent_record:, association_name:)
         ctx.included_records << serializer.serialize_record(ctx.fields, requested_relationships: requested)
-        ctx.processed.add(build_record_key(related_record))
       end
 
       # An included record serializes with the same request context as its
@@ -138,15 +158,10 @@ module JSONAPI
                                        authorization_context:, include_filter_cache:, namespace:,)
       end
 
+      # A two-slot array beats the string key: no interpolation, no copy of
+      # the class name, and the same class-plus-id identity.
       def build_record_key(related_record)
-        "#{related_record.class.name}-#{related_record.id}"
-      end
-
-      def serialize_nested_path(related_record, path_parts, path_from_root, ctx)
-        return unless path_parts.length > 1
-
-        nested_path = path_parts[1..].join(".")
-        serialize_include_path(related_record, nested_path, ctx, path_from_root: path_from_root)
+        [related_record.class, related_record.id]
       end
     end
   end

data/lib/json_api/serialization/concerns/meta_serialization.rb

@@ -22,8 +22,7 @@ module JSONAPI
       def fetch_instance_meta
         return unless definition.method_defined?(:meta)
 
-        instance = definition.new(@record, {})
-        instance.meta
+        definition_instance.meta
       end
 
       def fetch_class_meta

data/lib/json_api/serialization/serializer.rb

@@ -83,6 +83,14 @@ module JSONAPI
 
     attr_reader :record, :definition, :parent_record, :association_name, :authorization_context, :namespace
 
+    # One resource instance per serialized record, shared by the attribute
+    # reader and the meta reader. The two built separate instances, which
+    # doubled the instantiation and kept the resource's own memoized reads
+    # from being shared between an attribute and a meta entry.
+    def definition_instance
+      @definition_instance ||= definition.new(record)
+    end
+
     # Shared per request when the controller passes one in; a standalone
     # serializer builds its own, which still dedupes within its own walk.
     def include_filter_cache

data/lib/json_api/support/relationship_helpers.rb

@@ -63,7 +63,11 @@ module JSONAPI
     end
 
     def find_relationship_definition(definition, relationship_name)
-      definition.relationship_definitions.find { |r| r[:name].to_s == relationship_name.to_s }
+      if definition.respond_to?(:relationship_definition_index)
+        definition.relationship_definition_index[relationship_name]
+      else
+        definition.relationship_definitions.find { |r| r[:name].to_s == relationship_name.to_s }
+      end
     end
   end
 end

data/lib/json_api/support/resource_identifier.rb

@@ -73,9 +73,7 @@ module JSONAPI
     end
 
     def polymorphic_association?(definition, relationship_name)
-      relationship_def = definition.relationship_definitions.find do |r|
-        r[:name].to_s == relationship_name.to_s
-      end
+      relationship_def = RelationshipHelpers.find_relationship_definition(definition, relationship_name)
       return false unless relationship_def
 
       relationship_def[:options][:polymorphic] == true

data/lib/json_api/support/type_conversion.rb

@@ -9,15 +9,26 @@ module JSONAPI
     # relationship identifier. Cache frozen results keyed by name and format.
     # The railtie clears the cache on code reload.
     @type_name_cache = Concurrent::Map.new
+    # Identity front cache: the name-keyed cache still allocated its key
+    # string on every call. Nested by kind and format so a lookup allocates
+    # nothing; values come through the name-keyed cache, and both clear
+    # together on code reload.
+    @class_name_cache = Concurrent::Map.new
 
     def self.reset_cache!
       @type_name_cache.clear
+      @class_name_cache.clear
     end
 
     def self.type_name_cache
       @type_name_cache
     end
 
+    def self.class_name_bucket(kind, format)
+      by_kind = @class_name_cache.compute_if_absent(kind) { Concurrent::Map.new }
+      by_kind.compute_if_absent(format) { Concurrent::Map.new }
+    end
+
     module_function
 
     def type_to_class_name(type, namespace: nil)
@@ -38,8 +49,14 @@ module JSONAPI
       name = model_class.name
       return format_type_name(name.underscore.pluralize, format) if name.nil?
 
-      cache = TypeConversion.type_name_cache
-      cache["m|#{name}|#{format}"] ||= format_type_name(name.underscore.pluralize, format).freeze
+      bucket = TypeConversion.class_name_bucket(:model, format)
+      bucket[model_class] ||= named_type_name("m|#{name}|#{format}", name.underscore.pluralize, format)
+    end
+
+    # The name-keyed cache stays the source of truth so a reloaded class
+    # resolves to the same frozen string.
+    def named_type_name(key, full_name, format)
+      TypeConversion.type_name_cache[key] ||= format_type_name(full_name, format).freeze
     end
 
     def resource_type_name(definition_class, format: nil)
@@ -47,8 +64,9 @@ module JSONAPI
       name = definition_class.name
       return format_type_name(name.sub(/Resource$/, "").underscore.pluralize, format) if name.nil?
 
-      cache = TypeConversion.type_name_cache
-      cache["r|#{name}|#{format}"] ||= format_type_name(name.sub(/Resource$/, "").underscore.pluralize, format).freeze
+      bucket = TypeConversion.class_name_bucket(:resource, format)
+      bucket[definition_class] ||=
+        named_type_name("r|#{name}|#{format}", name.sub(/Resource$/, "").underscore.pluralize, format)
     end
 
     def format_type_name(full_name, format)

data/lib/json_api/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module JSONAPI
-  VERSION = "3.10.1"
+  VERSION = "3.11.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jpie
 version: !ruby/object:Gem::Version
-  version: 3.10.1
+  version: 3.11.0
 platform: ruby
 authors:
 - Emil Kampp