activerecord-duplicator 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bf58194f42894cf69c9ff83e02cd0f9f76fe38565e671e24ebb232221e8fa31
-  data.tar.gz: 1d20e02d28ef2bffcf831654d2b71fe73461d3eee0fa3b11ce5e95a15bac259a
+  metadata.gz: cc6a883e8a354d6b41962cb96eff90d95f083918fee428b0f865d5d254117f5c
+  data.tar.gz: 6b04468f4352d8d82f7a3cee8ccf684d19672d86715c4899313992a65519f362
 SHA512:
-  metadata.gz: ba02707cbdfdf479e2663bfcbf9b7d4012e1b1d43a9a483a041b76debff00d013e8b4f36efd7e81cb8e2e09d30a60b374a87345f625216dad0c75fee6898f1f0
-  data.tar.gz: 6871e902554ea9fc435b17bfa83e978a1034898bae00cf744edb61b191a89dc05bc479d316c6785a172a722f7d87b794114e173b819ed8176ccdffca380bd430
+  metadata.gz: f3ee11352e9d5612730e3a86f3f11d50e9becff4ac25651f1efef18dc9a6207da379e71751af1cf983e1bd880725200ce44c8c6f86da774242144942076996eb
+  data.tar.gz: 90472d33b56c36ab4d3688284cee4f6cacb2d6d3fa1f5cbfc3b44ba8ca5e5f52bcf176da680937d815cc2da0df97c558caee71fb196d03f1f816a2e53ab10f23

data/CHANGELOG.md

@@ -1,8 +1,34 @@
 ## [Unreleased]
 
+## [0.2.0] - 2026-07-06
+
 - Drop support for Ruby 3.2 (EOL)
 - Drop support for Rails 7.2; assume ActiveRecord >= 8.0 so `in_batches(cursor:)` is always available
 
+### Removed (breaking)
+
+- STI (Single Table Inheritance) dispatch in `Session#duplicate_records`.
+  Handlers are now looked up by the input Relation's `klass` (or the first
+  element's class for Arrays), with no ancestor walk and no `group_by(&:class)`.
+  If you were relying on registering a handler on a base class and expecting
+  it to fire for subclass records mixed in one Relation, split your input by
+  subclass and register handlers on each concrete class instead.
+
+### Changed (breaking)
+
+- Handlers now receive an `ActiveRecord::Relation` (not an Array) when the
+  input to duplication was a Relation. This lets `api.bulk_insert(klass,
+  records, cursor: [...])` take the `in_batches(cursor:)` path and enables
+  cursor-based keyset pagination for large child sets.
+- Default (handler-less) dispatch of a Relation now uses `find_in_batches`
+  internally, reducing peak memory for large child sets.
+
+### Migration
+
+- Handlers that previously used Array-only methods (`records.reject!`, etc.)
+  on the third argument must convert to Array explicitly:
+  `records = records.to_a`.
+
 ## [0.1.0] - 2026-07-02
 
 - Add `ActiveRecord::Duplicator::AssociationTraversal` — breadth-first traversal of preload-style association specifications

data/README.md

@@ -26,6 +26,17 @@ gem install activerecord-duplicator
 - PostgreSQL (via `pg` gem). The gem relies on `insert_all!` returning inserted
   primary keys.
 
+## Non-goals
+
+### STI dispatch
+
+This gem dispatches based on the class of the input Relation (or the first
+element for Arrays). If your Relation mixes STI subclasses and you need
+per-subclass handlers, split the input into per-subclass Relations before
+passing them in. Ancestor-walking dispatch (register a handler on a base class,
+have it fire for subclass records mixed in one Relation) is intentionally not
+supported; see CHANGELOG for details.
+
 ## Usage
 
 ### Basic duplication

data/lib/active_record/duplicator/session.rb

@@ -30,7 +30,6 @@ module ActiveRecord
         @record_id_map = Hash.new { |hash, klass| hash[klass] = {} }
         @handlers = handlers
         @user_handlers = {}
-        @handlers_cache = {}
       end
 
       # Register a handler that overrides Duplicator#on for the current session
@@ -42,8 +41,6 @@ module ActiveRecord
       # Duplicator-level handler is intentional and does not raise.
       #: (Class) { (HandlerApi, Class, untyped) -> void } -> void
       def on(klass, &block)
-        @handlers_cache.clear
-
         if @user_handlers.key?(klass)
           raise DuplicateHandlerError, "handler for #{klass} is already overridden in this session"
         end
@@ -145,10 +142,10 @@ module ActiveRecord
       #: (ActiveRecord::Base, ?associations: untyped) -> ActiveRecord::Base
       def run(root_record, associations: [])
         root_record.transaction(requires_new: true, joinable: false) do
-          duplicate_records([root_record])
+          duplicate_records(root_record.class, [root_record])
 
           AssociationTraversal.new(root_record, associations).each do |relation|
-            duplicate_records(relation)
+            duplicate_records(relation.klass, relation)
           end
 
           new_id = fetch_new_id(root_record.class, old_id: current_id(root_record))
@@ -158,45 +155,26 @@ module ActiveRecord
 
       private
 
-      #: (untyped) -> void
-      def duplicate_records(relation_or_records)
-        # Group by the real class of each record so a handler registered on an
-        # STI subclass fires only for records of that subclass. For non-STI
-        # models every record shares the given `klass`, so a single group is
-        # produced.
-        relation_or_records.group_by(&:class).each do |real_class, records|
-          handler = cache_or_resolve_handler(real_class)
+      # Dispatch to a handler (or the default bulk_insert path) for `klass`.
+      # All records in `relation_or_records` are assumed to be of `klass`; the
+      # caller is responsible for splitting mixed inputs (e.g. STI subclasses)
+      # into per-class Relations and passing the matching class in.
+      #: (Class, untyped) -> void
+      def duplicate_records(klass, relation_or_records)
+        handler = resolve_handler(klass)
 
-          if handler
-            handler.call(HandlerApi.new(self), real_class, records)
-          else
-            bulk_insert(real_class, records)
-          end
+        if handler
+          handler.call(HandlerApi.new(self), klass, relation_or_records)
+        else
+          bulk_insert(klass, relation_or_records)
         end
       end
 
-      #: (Class) -> Proc?
-      def cache_or_resolve_handler(klass)
-        @handlers_cache[klass] = resolve_handler(klass) unless @handlers_cache.key?(klass)
-
-        @handlers_cache[klass]
-      end
-
-      # Look up a handler for `klass` by walking its ancestor chain. Session
-      # -local handlers (Session#on) take precedence over any Duplicator-level
-      # handler, even one registered closer in the ancestor chain: the two
-      # passes below are deliberate, not a refactor opportunity.
+      # Session-local handlers (Session#on) take precedence over any
+      # Duplicator-level handler registered for the exact same class.
       #: (Class) -> Proc?
       def resolve_handler(klass)
-        # rubocop:disable Style/CombinableLoops
-        klass.ancestors.each do |ancestor|
-          return @user_handlers[ancestor] if @user_handlers.key?(ancestor)
-        end
-        klass.ancestors.each do |ancestor|
-          return @handlers[ancestor] if @handlers.key?(ancestor)
-        end
-        # rubocop:enable Style/CombinableLoops
-        nil
+        @user_handlers[klass] || @handlers[klass]
       end
 
       #: (untyped, batch_size: Integer, cursor: untyped) -> untyped

data/lib/active_record/duplicator/version.rb

@@ -2,6 +2,6 @@
 
 module ActiveRecord
   class Duplicator
-    VERSION = "0.1.0"
+    VERSION = "0.2.0"
   end
 end

data/sig/generated/active_record/duplicator/session.rbs

@@ -90,16 +90,15 @@ module ActiveRecord
 
       private
 
-      # : (untyped) -> void
-      def duplicate_records: (untyped) -> void
-
-      # : (Class) -> Proc?
-      def cache_or_resolve_handler: (Class) -> Proc?
-
-      # Look up a handler for `klass` by walking its ancestor chain. Session
-      # -local handlers (Session#on) take precedence over any Duplicator-level
-      # handler, even one registered closer in the ancestor chain: the two
-      # passes below are deliberate, not a refactor opportunity.
+      # Dispatch to a handler (or the default bulk_insert path) for `klass`.
+      # All records in `relation_or_records` are assumed to be of `klass`; the
+      # caller is responsible for splitting mixed inputs (e.g. STI subclasses)
+      # into per-class Relations and passing the matching class in.
+      # : (Class, untyped) -> void
+      def duplicate_records: (Class, untyped) -> void
+
+      # Session-local handlers (Session#on) take precedence over any
+      # Duplicator-level handler registered for the exact same class.
       # : (Class) -> Proc?
       def resolve_handler: (Class) -> Proc?
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-duplicator
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - SmartHR