paper_trail-human 0.3.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a4ca501d7c667357906931d0e4460948d92dcd0b8595f1162b0a25d980650c72
-  data.tar.gz: 87e69c7b0461fcf423fece4f6f8f6471214861f0fd2300ad484795a3eacc19c6
+  metadata.gz: f7c20298a4e2c9c68d4fe4b9a4e403b571fe3590d8970b32fd9cf20a8a902df9
+  data.tar.gz: 7f0e47633690bed45da988a5ff96f26cb9c83e61635710c27e15923da25322ce
 SHA512:
-  metadata.gz: d16233ba896c6f145177f3852b763aa7f8390cd12b68ae2077e2d9b7287e7cbb93d0944f940fafc77241161a5e5a0db764d160b75fde29338cc6e14143e14165
-  data.tar.gz: 342d5cdf3e9742e00bc58dab8ccfaca91b3a47e990d4dcfde4bc4b184c54e1a7f42af4830548f74bc444b2fd5ffcc8213759255950bc205049522595d9b4cdce
+  metadata.gz: faa5dd4c0f7d9b3598656b603225bab94fbcabe1e3fdc2a997a70e4357bfcf040508aa1c332dd0b13ca64b3ee8f6869f30df4a2e2a6edfc49e6607d602aa32e2
+  data.tar.gz: 319ccffdef16b6a533e7ec47ba422c2cc14d5a35dd75e8127064b0b5d523df15f682b269df89b8319cfe376722dbd0b3dec5b65b9bbb95f48e12cabbf15ddad8

data/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## [0.3.1] - 2026-05-31
+
+### Fixed
+- N+1 queries on `item_name` in `format_collection` and `timeline` (batch preloads records)
+- `Number` resolver with `format: :currency` and `unit: nil` no longer produces leading space
+- `format_collection` with `as:` option now joins entries with separators (double newline for text/markdown, newline for HTML)
+
+### Changed
+- Extracted `ItemNameLoader` and `RelationLoader` from `BatchPresenter` for better cohesion
+
 ## [0.3.0] - 2026-05-30
 
 ### Added

data/lib/paper_trail/human/adapters/resolvers/number.rb

@@ -45,7 +45,7 @@ module PaperTrail
           end
 
           def format_currency(num)
-            "#{@unit} #{format_number(num)}"
+            @unit ? "#{@unit} #{format_number(num)}" : format_number(num)
           end
 
           def format_percentage(num)

data/lib/paper_trail/human/core/batch_presenter.rb

@@ -7,29 +7,45 @@ module PaperTrail
         def initialize(configuration)
           @configuration = configuration
           @change_extractor = ChangeExtractor.new
+          @item_name_loader = ItemNameLoader.new(configuration)
+          @relation_loader = RelationLoader.new(configuration)
         end
 
         def call(versions, only: nil, except: nil)
           versions_data = versions.map { |v| [v, @change_extractor.call(v)] }
-          preloaded = preload_relations(versions_data)
+          preloaded = @relation_loader.preload(versions_data)
+          item_names = @item_name_loader.preload(versions)
 
           versions_data.map do |version, changes|
-            format_version(version, changes, preloaded, only: only, except: except)
+            format_version(version, changes, preloaded, item_names, only: only, except: except)
           end
         end
 
         private
 
-        def format_version(version, changes, preloaded, only: nil, except: nil)
+        # rubocop:disable Metrics/ParameterLists
+        def format_version(version, changes, preloaded, item_names, only: nil, except: nil)
+          # rubocop:enable Metrics/ParameterLists
+          formatter = build_formatter(version, preloaded)
+          result = base_result(version, changes, formatter, only: only, except: except)
+
+          item_name = @item_name_loader.resolve(version, item_names)
+          result[:item_name] = item_name if item_name
+
+          apply_after_format(result, version)
+        end
+
+        def build_formatter(version, preloaded)
           model_config = @configuration.config_for(version.item_type)
-          formatter = FieldFormatter.new(
-            model_config,
-            version.item_type,
+          FieldFormatter.new(
+            model_config, version.item_type,
             field_name_resolver: @configuration.field_name_resolver,
             preloaded: preloaded
           )
+        end
 
-          result = {
+        def base_result(version, changes, formatter, only: nil, except: nil)
+          {
             user: @configuration.resolve_whodunnit(version.whodunnit),
             event: EventTranslator.call(version.event, translate: @configuration.translate_events),
             model: version.item_type,
@@ -37,11 +53,6 @@ module PaperTrail
             created_at: version.created_at,
             fields: build_fields(changes, formatter, version.event, only: only, except: except)
           }
-
-          item_name = @configuration.resolve_item_name(version)
-          result[:item_name] = item_name if item_name
-
-          apply_after_format(result, version)
         end
 
         def build_fields(changes, formatter, event, only: nil, except: nil)
@@ -54,7 +65,6 @@ module PaperTrail
         def filter_field?(field, only, except)
           field_s = field.to_s
           return only.map(&:to_s).include?(field_s) if only
-
           return !except.map(&:to_s).include?(field_s) if except
 
           true
@@ -63,65 +73,13 @@ module PaperTrail
         def format_field(formatter, field, values, event)
           previous_value, new_value = Array(values)
           result = formatter.call(field, previous_value, new_value)
-
           case event
-          when 'create'
-            result.delete(:previous_value)
-          when 'destroy'
-            result.delete(:value)
+          when 'create' then result.delete(:previous_value)
+          when 'destroy' then result.delete(:value)
           end
-
           result
         end
 
-        def preload_relations(versions_data)
-          relation_fields = collect_relation_fields(versions_data)
-          return {} if relation_fields.empty?
-
-          relation_fields.each_with_object({}) do |(key, ids), cache|
-            class_name, attribute = key
-            cache[key] = load_records(class_name, attribute, ids)
-          end
-        end
-
-        def collect_relation_fields(versions_data)
-          result = Hash.new { |h, k| h[k] = Set.new }
-
-          versions_data.each do |version, changes|
-            collect_from_version(result, version, changes)
-          end
-
-          result
-        end
-
-        def collect_from_version(result, version, changes)
-          model_config = @configuration.config_for(version.item_type)
-          return unless model_config
-
-          changes.each do |field, values|
-            field_cfg = model_config.fields[field.to_s]
-            next unless field_cfg && field_cfg[:type] == :relation
-
-            key = relation_key(field_cfg)
-            Array(values).compact.each { |v| result[key].add(v) }
-          end
-        end
-
-        def relation_key(field_cfg)
-          class_name = field_cfg[:options][:class_name] || field_cfg[:options][:class].to_s
-          attribute = field_cfg[:options][:attribute] || :name
-          [class_name, attribute]
-        end
-
-        def load_records(class_name, attribute, ids)
-          klass = Object.const_get(class_name)
-          klass.where(id: ids.to_a).to_h do |record|
-            [record.id, record.public_send(attribute)]
-          end
-        rescue NameError
-          {}
-        end
-
         def apply_after_format(result, version)
           return result unless @configuration.after_format
 

data/lib/paper_trail/human/core/item_name_loader.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module PaperTrail
+  module Human
+    module Core
+      class ItemNameLoader
+        def initialize(configuration)
+          @configuration = configuration
+        end
+
+        def preload(versions)
+          grouped = group_batchable(versions)
+
+          grouped.each_with_object({}) do |(item_type, ids), cache|
+            load_names(item_type, ids, cache)
+          end
+        end
+
+        def resolve(version, cache)
+          model_config = @configuration.config_for(version.item_type)
+          return nil unless model_config&.item_name_attribute
+
+          attr = model_config.item_name_attribute
+          return attr.call(version) if attr.respond_to?(:call)
+
+          cache[[version.item_type, version.item_id]]
+        end
+
+        private
+
+        def group_batchable(versions)
+          versions.each_with_object({}) do |version, grouped|
+            model_config = @configuration.config_for(version.item_type)
+            next unless model_config&.item_name_attribute
+            next if model_config.item_name_attribute.respond_to?(:call)
+
+            (grouped[version.item_type] ||= Set.new).add(version.item_id)
+          end
+        end
+
+        def load_names(item_type, ids, cache)
+          attr = @configuration.config_for(item_type).item_name_attribute
+          klass = Object.const_get(item_type)
+          klass.where(id: ids.to_a).each do |record|
+            cache[[item_type, record.id]] = record.public_send(attr)
+          end
+        rescue NameError
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/paper_trail/human/core/relation_loader.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module PaperTrail
+  module Human
+    module Core
+      class RelationLoader
+        def initialize(configuration)
+          @configuration = configuration
+        end
+
+        def preload(versions_data)
+          relation_fields = collect_relation_fields(versions_data)
+          return {} if relation_fields.empty?
+
+          relation_fields.each_with_object({}) do |(key, ids), cache|
+            class_name, attribute = key
+            cache[key] = load_records(class_name, attribute, ids)
+          end
+        end
+
+        private
+
+        def collect_relation_fields(versions_data)
+          result = Hash.new { |h, k| h[k] = Set.new }
+
+          versions_data.each do |version, changes|
+            collect_from_version(result, version, changes)
+          end
+
+          result
+        end
+
+        def collect_from_version(result, version, changes)
+          model_config = @configuration.config_for(version.item_type)
+          return unless model_config
+
+          changes.each do |field, values|
+            field_cfg = model_config.fields[field.to_s]
+            next unless field_cfg && field_cfg[:type] == :relation
+
+            key = relation_key(field_cfg)
+            Array(values).compact.each { |v| result[key].add(v) }
+          end
+        end
+
+        def relation_key(field_cfg)
+          class_name = field_cfg[:options][:class_name] || field_cfg[:options][:class].to_s
+          attribute = field_cfg[:options][:attribute] || :name
+          [class_name, attribute]
+        end
+
+        def load_records(class_name, attribute, ids)
+          klass = Object.const_get(class_name)
+          klass.where(id: ids.to_a).to_h { |record| [record.id, record.public_send(attribute)] }
+        rescue NameError
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/paper_trail/human/version.rb

@@ -2,6 +2,6 @@
 
 module PaperTrail
   module Human
-    VERSION = '0.3.0'
+    VERSION = '0.3.1'
   end
 end

data/lib/paper_trail/human.rb

@@ -7,6 +7,8 @@ require_relative 'human/core/field_formatter'
 require_relative 'human/core/event_translator'
 require_relative 'human/core/presenter'
 require_relative 'human/core/batch_presenter'
+require_relative 'human/core/item_name_loader'
+require_relative 'human/core/relation_loader'
 require_relative 'human/core/timeline'
 require_relative 'human/ports/resolver'
 require_relative 'human/adapters/resolvers/relation'
@@ -54,7 +56,15 @@ module PaperTrail
 
       def format_collection(versions, only: nil, except: nil, as: nil)
         results = Core::BatchPresenter.new(configuration).call(versions, only: only, except: except)
-        as ? results.map { |r| formatter(as).call(r) } : results
+        return results unless as
+
+        formatted = results.map { |r| formatter(as).call(r) }
+        separator = as.to_sym == :html ? "\n" : "\n\n"
+        formatted.join(separator)
+      end
+
+      def timeline(versions, group_by: :day, only: nil, except: nil)
+        Core::Timeline.new(configuration).call(versions, group_by: group_by, only: only, except: except)
       end
 
       private
@@ -65,10 +75,6 @@ module PaperTrail
 
         klass.new
       end
-
-      def timeline(versions, group_by: :day, only: nil, except: nil)
-        Core::Timeline.new(configuration).call(versions, group_by: group_by, only: only, except: except)
-      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: paper_trail-human
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 0.3.1
 platform: ruby
 authors:
 - Gabriel
@@ -67,7 +67,9 @@ files:
 - lib/paper_trail/human/core/change_extractor.rb
 - lib/paper_trail/human/core/event_translator.rb
 - lib/paper_trail/human/core/field_formatter.rb
+- lib/paper_trail/human/core/item_name_loader.rb
 - lib/paper_trail/human/core/presenter.rb
+- lib/paper_trail/human/core/relation_loader.rb
 - lib/paper_trail/human/core/timeline.rb
 - lib/paper_trail/human/ports/resolver.rb
 - lib/paper_trail/human/railtie.rb