jpie 1.5.0 → 1.5.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d6718c74febd247abaa1dd7294fd729209a3e905363e02d8bb88f20e6a8ee92e
-  data.tar.gz: 388c8ee9564f191f14e87d0095d15657dd4ccb55c841d26755d8d7916811d0f0
+  metadata.gz: be60282bbba362a7ac36dca3370a4733981bce7a949352513244879bc76546a7
+  data.tar.gz: 6c391beea011b7fd348f8a2439130ba174dd31fa7b8f9f4ea6eaef5c9fd916ee
 SHA512:
-  metadata.gz: d4188461bf266a55290b2728691e8b052b8f8eeb2ba319949aa0fbb23109dc9175e2c7d29aa53e3768fe794738cd7f5b70e83f624ec0ff72af13051159eb4800
-  data.tar.gz: dd193aec85fc8fb12ef21200eca3341411d7c12c0e32f5d2d50562d4fcbefd76ddfc4d08ea36b2c69204c2b579fa2dd9cac18cd2aa4540898f4a9f9543422218
+  metadata.gz: 13f21d51760a269d54d1bcd46a9be3916506bae8c25af82eaabea8dc7a214d2f3d39b29437ca0703141a794444d13b7ab20ba26ac4f35f4fe3a8ca15207d1630
+  data.tar.gz: 35e11173e5942bc01059217acf3a5028f5980108b2c76e88b33fe03c9c2ae00a4a6a9c0051328e491a257d83700f02f6a206c7a34406cde968af1a6698ac63fd

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    jpie (1.5.0)
+    jpie (1.5.1)
       actionpack (~> 8.0, >= 8.0.0)
       rails (~> 8.0, >= 8.0.0)
 

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

@@ -2,34 +2,62 @@
 
 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,)
+
     module IncludesSerialization
+      include IncludePathHelpers
+
       def serialize_included(includes, fields = {})
         all_includes = normalize_include_paths(includes)
         return [] if all_includes.empty?
 
-        included_records = []
-        processed = Set.new
-
-        all_includes.each do |include_path|
-          serialize_include_path(record, include_path, fields, included_records, processed, all_includes:)
-        end
+        ctx = build_include_context(fields, all_includes)
+        all_includes.each { |path| serialize_include_path(record, path, ctx, path_from_root: "") }
+        ctx.included_records
+      end
 
-        included_records
+      def build_include_context(fields, all_includes)
+        IncludeContext.new(
+          fields: fields,
+          included_records: [],
+          processed: Set.new,
+          all_includes: all_includes,
+        )
       end
 
       private
 
-      def serialize_include_path(current_record, include_path, fields, included_records, processed, all_includes:)
+      def serialize_include_path(current_record, include_path, ctx, path_from_root: "")
         path_parts = include_path.split(".")
         association_name = path_parts.first.to_sym
-
         return unless valid_include_association?(current_record, association_name)
 
-        related_array = get_related_records(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)
+      end
+
+      def process_related_records(related_array, path_ctx, ctx)
         related_array.each do |related_record|
-          parent_context = self.class.active_storage_attachment?(association_name, current_record.class) ? { parent_record: current_record, association_name: } : {}
-          serialize_and_process_record(related_record, include_path, all_includes, fields, included_records, processed, **parent_context)
-          serialize_nested_path(related_record, path_parts, fields, included_records, processed, all_includes:)
+          iter = IncludeIteration.new(related_record: related_record, **path_ctx.to_h)
+          serialize_related_record(iter, ctx)
+        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: }
+        else
+          {}
         end
       end
 
@@ -81,53 +109,24 @@ module JSONAPI
         [attachment.blob].compact
       end
 
-      def serialize_and_process_record(related_record, include_path, all_includes, fields, included_records, processed, parent_record: nil, association_name: nil) # rubocop:disable Metrics/ParameterLists
-        record_key = build_record_key(related_record)
-        return if processed.include?(record_key)
+      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))
 
-        requested_relationships = include_paths_to_relationship_names(all_includes, include_path)
+        requested = include_paths_to_relationship_names(ctx.all_includes, path_to_record)
         serializer = self.class.new(related_record, parent_record:, association_name:)
-        included_records << serializer.serialize_record(fields, requested_relationships: requested_relationships)
-        processed.add(record_key)
+        ctx.included_records << serializer.serialize_record(ctx.fields, requested_relationships: requested)
+        ctx.processed.add(build_record_key(related_record))
       end
 
       def build_record_key(related_record)
         "#{related_record.class.name}-#{related_record.id}"
       end
 
-      def serialize_nested_path(related_record, path_parts, fields, included_records, processed, all_includes:)
+      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, fields, included_records, processed,
-                               all_includes: all_includes,)
-      end
-
-      def normalize_include_paths(include_param)
-        case include_param
-        when Array
-          include_param.flat_map { |s| s.to_s.split(",").map(&:strip) }.uniq
-        when String
-          include_param.split(",").map(&:strip)
-        else
-          []
-        end
-      end
-
-      def include_paths_to_relationship_names(include_paths, path_prefix)
-        return [] if include_paths.blank?
-
-        prefix = path_prefix.present? ? "#{path_prefix}." : ""
-        include_paths.filter_map do |p|
-          path = p.to_s
-          next unless path == path_prefix || path.start_with?(prefix)
-
-          segments = path.split(".")
-          prefix_segments = path_prefix.split(".")
-          next if segments.length <= prefix_segments.length
-
-          segments[prefix_segments.length].to_sym
-        end.uniq
+        serialize_include_path(related_record, nested_path, ctx, path_from_root: path_from_root)
       end
     end
   end

data/lib/json_api/serialization/include_path_helpers.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Serialization
+    module IncludePathHelpers
+      def normalize_include_paths(include_param)
+        case include_param
+        when Array
+          include_param.flat_map { |s| s.to_s.split(",").map(&:strip) }.uniq
+        when String
+          include_param.split(",").map(&:strip)
+        else
+          []
+        end
+      end
+
+      def include_paths_to_relationship_names(include_paths, path_prefix)
+        return [] if include_paths.blank?
+
+        prefix = path_prefix.present? ? "#{path_prefix}." : ""
+        include_paths.filter_map do |p|
+          path = p.to_s
+          next unless path == path_prefix || path.start_with?(prefix)
+
+          segments = path.split(".")
+          prefix_segments = path_prefix.split(".")
+          next if segments.length <= prefix_segments.length
+
+          segments[prefix_segments.length].to_sym
+        end.uniq
+      end
+    end
+  end
+end

data/lib/json_api/serialization/serializer.rb

@@ -3,6 +3,7 @@
 require_relative "concerns/attributes_serialization"
 require_relative "concerns/relationships_serialization"
 require_relative "concerns/links_serialization"
+require_relative "include_path_helpers"
 require_relative "concerns/includes_serialization"
 require_relative "concerns/meta_serialization"
 

data/lib/json_api/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jpie
 version: !ruby/object:Gem::Version
-  version: 1.5.0
+  version: 1.5.1
 platform: ruby
 authors:
 - Emil Kampp
@@ -126,6 +126,7 @@ files:
 - lib/json_api/serialization/concerns/relationships_deserialization.rb
 - lib/json_api/serialization/concerns/relationships_serialization.rb
 - lib/json_api/serialization/deserializer.rb
+- lib/json_api/serialization/include_path_helpers.rb
 - lib/json_api/serialization/serializer.rb
 - lib/json_api/support/active_storage_support.rb
 - lib/json_api/support/collection_query.rb