copyable 0.1.1 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 4e51f2b73f6b3f642d8b9174567c245c2f875b6a
-  data.tar.gz: c56647390d32496da7fbe0f971d9e86d2299b070
+SHA256:
+  metadata.gz: 2a08309e56270ce4847101314203835381cb28e1ece99a477391cc23461e3d78
+  data.tar.gz: 440110e69f8828d034ba8b01dcbae7bc56e011aea751a69f202423ffa66859f0
 SHA512:
-  metadata.gz: 236d9f5a60f236f49d99b2a8f47586ea2678bbd1c2a97c86d2e0dd7eaabf4dafe90065f8e09b9fd32b6f8c9c75188e4ee27c4977c9e3ffd198a85124ed1c13c5
-  data.tar.gz: b59f9f190720c3dbc37646795017d52953078f7bf8d7a2726fef9aa891e29c67579e911d021029b9b2def2f9898f4a5f05b163644bbba2e7fcdea506b50bcb6d
+  metadata.gz: 65fd03e6dce5bfd47f6aa2f784f4a8cab6d061ad6d3c693609239a848af4867bae34cded904a9c540041631cc456b636c44e70e0b6c6a8ab94fe0e07f2e197a9
+  data.tar.gz: '0585f34ccded08588ad09aa76a13834846c17c082a783da6f4f4f96f80d3d96156f54437022edf62c521eda8202e06fa02d5b8f24ddc921b401cf4251d591891'

data/README.md

@@ -121,16 +121,9 @@ The advice must be one of the following:
 
 ## Callbacks
 
-It depends on the situation as to whether you would want a particular callback to be fired when a model is copied.  Since the logic of callbacks is situational, Copyable makes the decision to completely disable all callbacks and observers for the duration of the `create_copy!` method.  The only exception are callbacks and observers related to validation.
-
-To make it easier to reason about the code, and for the sake of being obvious, every copyable declaration *must* include a declaration called `disable_all_callbacks_and_observers_except_validate`.  This declaration itself does not do anything; it exists as documentation.
-
-    copyable do
-      disable_all_callbacks_and_observers_except_validate
-      ...
-    end
-
-
+It depends on the situation as to whether you would want a particular callback to be fired when a model is copied.  Since the logic of callbacks is situational, Copyable makes the decision to bypass callbacks
+when saving the copied models by using raw SQL insert statements during the copy. It will check
+validations unless `skip_validations` is passed to `create_copy`.
 
 ## The After Copy Declaration
 
@@ -267,4 +260,4 @@ So the recommended approach is to use `after_copy` to tweak the columns of the c
 
 ## About
 
-Copyable was developed at [District Management Group](https://dmgroupK12.com).
+Copyable was developed at [District Management Group](https://dmgroupK12.com).

data/copyable.gemspec

@@ -6,8 +6,8 @@ require 'copyable/version'
 Gem::Specification.new do |spec|
   spec.name          = "copyable"
   spec.version       = Copyable::VERSION
-  spec.authors       = ["Wyatt Greene", "Dennis Chan"]
-  spec.email         = ["dchan@dmcouncil.org"]
+  spec.authors       = ["Wyatt Greene", "Dennis Chan", "Anne Geiersbach", "Parker Morse"]
+  spec.email         = ["dchan@dmgroupK12.com", "ageiersbach@dmgroupK12.com", "pmorse@dmgroupK12.com"]
   spec.summary       = %q{ActiveRecord copier}
   spec.description   = %q{Copyable makes it easy to copy ActiveRecord models.}
   spec.homepage      = "https://github.com/dmcouncil/copyable"
@@ -18,11 +18,11 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "activerecord", "~>4.1.0"
+  spec.add_dependency "activerecord", "5.2.6"
 
-  spec.add_development_dependency "database_cleaner", "~> 1.4.0"
-  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "database_cleaner", "~> 2"
+  spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "sqlite3"
+  spec.add_development_dependency "sqlite3", "~> 1.3.6"
 end

data/lib/copyable/copyable_extension.rb

@@ -49,6 +49,8 @@ module Copyable
               # fill in each column of this brand new model according to the
               # instructions given in the copyable declaration
               column_overrides = options[:override] || {}
+              # merge with global override hash if exists
+              column_overrides = column_overrides.merge(options[:global_override]) if options[:global_override]
               Declarations::Columns.execute(main.column_list, original_model, new_model, column_overrides)
               # save that sucker!
               Copyable::Saver.save!(new_model, options[:skip_validations])
@@ -61,7 +63,7 @@ module Copyable
               # declaration
 
               skip_associations = options[:skip_associations] || []
-              Declarations::Associations.execute(main.association_list, original_model, new_model, options[:skip_validations], skip_associations)
+              Declarations::Associations.execute(main.association_list, original_model, new_model, options[:global_override], options[:skip_validations], skip_associations)
               # run the after_copy block if it exists
               Declarations::AfterCopy.execute(main.after_copy_block, original_model, new_model)
             ensure

data/lib/copyable/declarations/associations.rb

@@ -6,10 +6,12 @@ module Copyable
 
         # this is the algorithm for copying associated records according to the
         # instructions given in the copyable declaration
-        def execute(association_list, original_model, new_model, skip_validations, skip_associations)
+        def execute(association_list, original_model, new_model, global_override = {}, skip_validations, skip_associations)
           @skip_validations = skip_validations
+          @skip_associations = skip_associations
+          @global_override = global_override
           association_list.each do |assoc_name, advice|
-            association = original_model.class.reflections[assoc_name.to_sym]
+            association = original_model.class.reflections[assoc_name.to_s]
             check_advice(association, advice, original_model)
             unless advice == :do_not_copy || skip_associations.include?(assoc_name.to_sym)
               copy_association(association, original_model, new_model)
@@ -26,14 +28,14 @@ module Copyable
             message << "has unrecognized advice '#{advice}'."
             raise AssociationError.new(message)
           end
-          if association.macro == :has_and_belongs_to_many && advice == :copy
+          if association.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection) && advice == :copy
             message = "Error in copyable:associations of "
             message << "#{original_model.class.name}: the association '#{association.name}' "
             message << "only supports the :copy_only_habtm_join_records advice, not the :copy advice, "
             message << "because it is a has_and_belongs_to_many association."
             raise AssociationError.new(message)
           end
-          if association.macro != :has_and_belongs_to_many && advice == :copy_only_habtm_join_records
+          if !association.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection) && advice == :copy_only_habtm_join_records
             message = "Error in copyable:associations of "
             message << "#{original_model.class.name}: the association '#{association.name}' "
             message << "only supports the :copy advice, not the :copy_only_habtm_join_records advice, "
@@ -43,15 +45,14 @@ module Copyable
         end
 
         def copy_association(association, original_model, new_model)
-          case association.macro
-          when :has_many
+          if association.is_a?(ActiveRecord::Reflection::HasManyReflection)
             copy_has_many(association, original_model, new_model)
-          when :has_one
+          elsif association.is_a?(ActiveRecord::Reflection::HasOneReflection)
             copy_has_one(association, original_model, new_model)
-          when :has_and_belongs_to_many
+          elsif association.is_a?(ActiveRecord::Reflection::HasAndBelongsToManyReflection)
             copy_habtm(association, original_model, new_model)
           else
-            raise "Unsupported association #{association.macro}" # should never happen, since we filter out belongs_to
+            raise "Unsupported association #{association.class}" # should never happen, since we filter out belongs_to
           end
         end
 
@@ -78,7 +79,9 @@ module Copyable
               copied_record = original_record.create_copy!(
                 override: { association.foreign_key => parent_model.id },
                 __called_recursively: true,
-                skip_validations: @skip_validations)
+                global_override: @global_override,
+                skip_validations: @skip_validations,
+                skip_associations: @skip_associations)
             else
               message = "Could not copy #{parent_model.class.name}#id:#{parent_model.id} "
               message << "because #{original_record.class.name} does not have a copyable declaration."

data/lib/copyable/model_hooks.rb

@@ -16,30 +16,33 @@ module Copyable
 
     def self.disable_all_callbacks(klass)
       klass.class_eval do
-        # Don't do it if it was already done
-        return if self.method_defined? :__disabled__run_callbacks
-
-        alias_method :__disabled__run_callbacks, :run_callbacks
-        # We are violently duck-punching ActiveRecord because ActiveRecord
-        # gives us no way to turn off callbacks.  My apologies to the
-        # squeamish.
-        def run_callbacks(kind, *args, &block)
-          if block_given?
-            yield
-          else
-            true
-          end
+        return if self.method_defined? :old_save! # Don't do this more than once
+
+        @all_callbacks_disabled = true
+        class << self
+          attr_reader :all_callbacks_disabled
+        end
+
+        alias_method :old_save!, :save!
+
+        # Hold my beer while we bypass all the Rails callbacks
+        # in favor of some raw SQL
+        def save!
+          Copyable::Saver.save!(self)
         end
       end
     end
 
     def self.reenable_all_callbacks(klass)
       klass.class_eval do
-        # Only do it if the disabled callbacks are defined
-        return unless self.method_defined? :__disabled__run_callbacks
+        return unless self.method_defined? :old_save! # Don't do this more than once
+        @all_callbacks_disabled = false
+        class << self
+          attr_reader :all_callbacks_disabled
+        end
 
-        alias_method :run_callbacks, :__disabled__run_callbacks
-        remove_method :__disabled__run_callbacks
+        alias_method :save!, :old_save!
+        remove_method :old_save!
       end
     end
 

data/lib/copyable/option_checker.rb

@@ -1,7 +1,7 @@
 module Copyable
   class OptionChecker
 
-    VALID_OPTIONS = [:override, :skip_validations, :skip_associations]
+    VALID_OPTIONS = [:override, :global_override, :skip_validations, :skip_associations]
     VALID_PRIVATE_OPTIONS = [:__called_recursively]  # for copyable's internal use only
 
     def self.check!(options)

data/lib/copyable/saver.rb

@@ -1,19 +1,27 @@
 module Copyable
   class Saver
 
+    def self.direct_sql_insert!(new_model)
+      new_model.send(:_create_record) # bypass all callbacks and validations
+    end
+
+    def self.direct_sql_update!(new_model)
+      new_model.send(:_update_record) # bypass all callbacks and validations
+    end
+
     # this is the algorithm for saving the new record
-    def self.save!(new_model, skip_validations)
-      unless skip_validations
-        ModelHooks.reenable!(new_model.class) # we must re-enable or validation does not work
-        if !new_model.valid?(:create)
-          ModelHooks.disable!(new_model.class)
-          raise(ActiveRecord::RecordInvalid.new(new_model))
-        else
-          ModelHooks.disable!(new_model.class)
-        end
+    def self.save!(new_model, skip_validations=false)
+      unless skip_validations || new_model.valid?(:create)
+        raise(ActiveRecord::RecordInvalid.new(new_model))
       end
-      new_model.save!
-    end
 
+      if new_model.class.all_callbacks_disabled && new_model.id.nil?
+        self.direct_sql_insert!(new_model)
+      elsif new_model.class.all_callbacks_disabled
+        self.direct_sql_update!(new_model)
+      else
+        new_model.save!
+      end
+    end
   end
 end

data/lib/copyable/syntax_checking/association_checker.rb

@@ -10,7 +10,8 @@ module Copyable
     def expected_entries
       all_associations = model_class.reflect_on_all_associations
       required_associations = all_associations.select do |ass|
-        (ass.macro != :belongs_to) && ass.options[:through].blank?
+        !ass.is_a?(ActiveRecord::Reflection::BelongsToReflection) &&
+        !ass.is_a?(ActiveRecord::Reflection::ThroughReflection)
       end
       required_associations.map(&:name).map(&:to_s)
     end

data/lib/copyable/version.rb

@@ -1,3 +1,3 @@
 module Copyable
-  VERSION = "0.1.1"
+  VERSION = "0.3.1"
 end

data/lib/tasks/copyable.rake

@@ -39,7 +39,8 @@ task :copyable => :environment do
 
   all_associations = model_class.reflect_on_all_associations
   required_associations = all_associations.select do |ass|
-    (ass.macro != :belongs_to) && ass.options[:through].blank?
+    !ass.is_a?(ActiveRecord::Reflection::BelongsToReflection) &&
+    !ass.is_a?(ActiveRecord::Reflection::ThroughReflection)    
   end
   associations = required_associations.map(&:name).map(&:to_s)
   max_length = associations.map(&:length).max

data/spec/deep_structure_copy_spec.rb

@@ -89,6 +89,13 @@ describe 'complex model hierarchies:' do
       expect(CopyableWarranty.count).to eq(3) # Because the amenities weren't copied either
     end
 
+    it 'should skip nested branches of the tree when directed' do
+      @vehicle2 = @vehicle1.create_copy!(skip_associations: [:copyable_warranty])
+      expect(CopyableVehicle.count).to eq(2)
+      expect(CopyableAmenity.count).to eq(6)
+      expect(CopyableWarranty.count).to eq(3) # No new ones created
+    end
+
     it 'should create the expected records if copied multiple times' do
       # this test makes sure the SingleCopyEnforcer isn't too eager
       @vehicle1.create_copy!
@@ -122,6 +129,20 @@ describe 'complex model hierarchies:' do
         expect(CopyableVehicle.count).to eq(2)
         expect(CopyableAmenity.count).to eq(2)
       end
+
+      context 'with a global override, can copy vehicle with new owner' do
+        before(:each) do
+          @jane = CopyableOwner.create!(name: 'Jane')
+        end
+
+        it 'should copy the records correctly' do
+          @copy_of_joes_car = @porsche.create_copy!(global_override: { copyable_owner_id: @jane.id })
+          expect(CopyableVehicle.count).to eq(2)
+          expect(CopyableAmenity.count).to eq(2)
+          expect(@copy_of_joes_car.copyable_owner_id).to eq(@jane.id)
+          expect(@copy_of_joes_car.copyable_amenities.map(&:copyable_owner_id).uniq).to eq([@jane.id])
+        end
+      end
     end
 
     context 'with many models, some having redundant associations' do

data/spec/helper/test_tables.rb

@@ -11,14 +11,14 @@ module Copyable
 
           create_table :copyable_albums, force: true do |t|
             t.string :name, null: false
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_amenities, force: true do |t|
             t.string   :name
             t.integer  :copyable_vehicle_id
             t.integer  :copyable_owner_id
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_addresses, force: true do |t|
@@ -27,30 +27,30 @@ module Copyable
             t.string   :city,                     null: false
             t.string   :state,                    null: false
             t.integer  :copyable_pet_profile_id,  null: false
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_cars, force: true do |t|
             t.string   :make,   null: false
             t.string   :model,  null: false
             t.integer  :year,   null: false
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_coins, force: true do |t|
             t.string  :kind
             t.integer :year
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_owners, force: true do |t|
             t.string :name, null: false
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_pet_foods, force: true do |t|
             t.string :name, null: false
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_pet_foods_pets, force: true, id: false do |t|
@@ -62,31 +62,31 @@ module Copyable
             t.string   :description,     null: false
             t.string   :nickname
             t.integer  :copyable_pet_id, null: false
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_pet_sitters, force: true do |t|
             t.string  :name, null: false
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_pet_sitting_patronages, force: true do |t|
             t.integer  :copyable_pet_id,        null: false
             t.integer  :copyable_pet_sitter_id, null: false
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_pet_tags, force: true do |t|
             t.string   :registered_name, null: false
             t.integer  :copyable_pet_id, null: false
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_pets, force: true do |t|
             t.string  :name,        null: false
             t.string  :kind,        null: false
             t.integer :birth_year
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_pictures, force: true do |t|
@@ -94,36 +94,36 @@ module Copyable
             t.integer :imageable_id
             t.string  :imageable_type
             t.integer :picture_album_id
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_products, force: true do |t|
             t.string  :name
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_toys, force: true do |t|
             t.string   :name
             t.string   :kind
             t.integer  :copyable_pet_id
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_trees, force: true do |t|
             t.string  :kind
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_vehicles, force: true do |t|
             t.string  :name
             t.integer :copyable_owner_id
-            t.timestamps
+            t.timestamps null: false
           end
 
           create_table :copyable_warranties, force: true do |t|
             t.string   :name
             t.integer  :copyable_amenity_id
-            t.timestamps
+            t.timestamps null: false
           end
 
         end

data/spec/model_hooks_spec.rb

@@ -9,85 +9,31 @@ describe Copyable::ModelHooks do
       before(:each) do
         Copyable::ModelHooks.disable!(CopyableTree)
       end
+
       after(:each) do
         Copyable::ModelHooks.reenable!(CopyableTree)
       end
-      it 'should prevent callbacks from executing' do
-        expect {
-          CopyableTree.create!(kind: 'magnolia')
-        }.to_not raise_error
+
+      it 'defines an instance variable on the class' do
+        expect(CopyableTree.all_callbacks_disabled).to eq(true)
       end
+
       it 'should not prevent model actions from executing' do
         expect(CopyableTree.count).to eq(0)
-        CopyableTree.create!(kind: 'magnolia')
-        expect(CopyableTree.count).to eq(1)
       end
     end
 
     describe '.reenable!' do
-      it 'should allow callbacks to execute again' do
-        Copyable::ModelHooks.disable!(CopyableTree)
+      it 'defines an instance variable on the class' do
         Copyable::ModelHooks.reenable!(CopyableTree)
-        expect {
-          CopyableTree.create!(kind: 'magnolia')
-        }.to raise_error(RuntimeError, "callback2 called")
+        expect(CopyableTree.all_callbacks_disabled).to eq(false)
       end
-    end
-  end
-
-  context 'validations' do
 
-    # Note: the relevant model and observer class is defined in helper/test_models.rb
-
-    describe '.disable!' do
-      before(:each) do
-        Copyable::ModelHooks.disable!(CopyableCoin)
-      end
-      after(:each) do
-        Copyable::ModelHooks.reenable!(CopyableCoin)
-      end
-      it 'should prevent validations from executing' do
-        expect {
-          CopyableCoin.create!(year: -10)
-        }.to_not raise_error
-      end
-      it 'should not prevent model actions from executing' do
-        expect(CopyableCoin.count).to eq(0)
-        CopyableCoin.create!(year: -10)
-        expect(CopyableCoin.count).to eq(1)
-      end
-    end
-
-    describe '.reenable!' do
-      it 'should allow validations to execute again' do
-        Copyable::ModelHooks.disable!(CopyableCoin)
-        Copyable::ModelHooks.reenable!(CopyableCoin)
+      it 'should allow callbacks to execute again' do
         expect {
-          CopyableCoin.create!(year: -10)
-        }.to raise_error(ActiveRecord::RecordInvalid)
+          CopyableTree.create!(kind: 'magnolia')
+        }.to raise_error(RuntimeError, "callback2 called")
       end
     end
   end
-
-  describe 'nested disables and enables' do
-    it 'should allow callbacks to execute again' do
-      Copyable::ModelHooks.disable!(CopyableTree)
-      expect { CopyableTree.create!(kind: 'magnolia') }.to_not raise_error
-
-      Copyable::ModelHooks.disable!(CopyableCoin)
-      expect { CopyableCoin.create!(year: -10) }.to_not raise_error
-
-      Copyable::ModelHooks.disable!(CopyableTree)
-      expect { CopyableTree.create!(kind: 'magnolia') }.to_not raise_error
-
-      Copyable::ModelHooks.reenable!(CopyableCoin)
-      expect { CopyableCoin.create!(year: -10) }.to raise_error(ActiveRecord::RecordInvalid)
-
-      Copyable::ModelHooks.reenable!(CopyableTree)
-      expect { CopyableTree.create!(kind: 'magnolia') }.to raise_error(RuntimeError)
-
-      Copyable::ModelHooks.reenable!(CopyableTree)
-      expect { CopyableTree.create!(kind: 'magnolia') }.to raise_error(RuntimeError)
-    end
-  end
 end

metadata

@@ -1,58 +1,60 @@
 --- !ruby/object:Gem::Specification
 name: copyable
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.3.1
 platform: ruby
 authors:
 - Wyatt Greene
 - Dennis Chan
-autorequire: 
+- Anne Geiersbach
+- Parker Morse
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-02-08 00:00:00.000000000 Z
+date: 2021-08-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: 5.2.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: 4.1.0
+        version: 5.2.6
 - !ruby/object:Gem::Dependency
   name: database_cleaner
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: '2'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.4.0
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -85,19 +87,21 @@ dependencies:
   name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.3.6
 description: Copyable makes it easy to copy ActiveRecord models.
 email:
-- dchan@dmcouncil.org
+- dchan@dmgroupK12.com
+- ageiersbach@dmgroupK12.com
+- pmorse@dmgroupK12.com
 executables: []
 extensions: []
 extra_rdoc_files: []
@@ -158,7 +162,7 @@ homepage: https://github.com/dmcouncil/copyable
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -173,9 +177,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.12
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: ActiveRecord copier
 test_files: