copyable 0.0.1

data/spec/copyable_columns_spec.rb

@@ -0,0 +1,116 @@
+require_relative 'helper/copyable_spec_helper'
+
+describe 'copyable:columns' do
+  context 'when asked to do a simple column copy' do
+    include ActiveSupport::Testing::TimeHelpers
+
+    before(:each) do
+      undefine_copyable_in CopyableCoin
+      class CopyableCoin < ActiveRecord::Base
+        copyable do
+          disable_all_callbacks_and_observers_except_validate
+          columns({
+            kind:  :copy,
+            year:  :copy,
+          })
+          associations({
+          })
+        end
+      end
+    end
+
+    it 'should create a new record with matching columns' do
+      expect(CopyableCoin.count).to eq(0)
+      coin = CopyableCoin.create!(kind: 'cent', year: 1943)
+      coin.create_copy!
+      expect(CopyableCoin.where(kind: 'cent').count).to eq(2)
+      expect(CopyableCoin.where(year: 1943).count).to eq(2)
+    end
+
+    it 'should update timestamp columns' do
+      expect(CopyableCoin.count).to eq(0)
+      coin = CopyableCoin.create!(kind: 'cent', year: 1943)
+      travel_to 2.seconds.from_now do
+        coin_copy = coin.create_copy!
+        expect(coin_copy.updated_at).to be_present
+        expect(coin_copy.created_at).to be_present
+        expect(coin_copy.updated_at).not_to eq(coin.updated_at)
+        expect(coin_copy.created_at).not_to eq(coin.created_at)
+      end
+    end
+  end
+
+  context 'when asked to do a column copy with customization' do
+    before(:each) do
+      undefine_copyable_in CopyableCoin
+      class CopyableCoin < ActiveRecord::Base
+        copyable do
+          disable_all_callbacks_and_observers_except_validate
+          columns({
+            kind:  lambda { |orig| "Copy of #{orig.kind}" },
+            year:  :copy,
+          })
+          associations({
+          })
+        end
+      end
+    end
+    describe '#create_copy!' do
+      it 'should create a new record with the customized column' do
+        expect(CopyableCoin.count).to eq(0)
+        coin = CopyableCoin.create!(kind: 'quarter', year: 1964)
+        coin.create_copy!
+        expect(CopyableCoin.where(kind: 'quarter').count).to eq(1)
+        expect(CopyableCoin.where(kind: 'Copy of quarter').count).to eq(1)
+        expect(CopyableCoin.where(year: 1964).count).to eq(2)
+      end
+    end
+  end
+
+  context 'when asked to do a copy that produces invalid data' do
+    before(:each) do
+      undefine_copyable_in CopyableCoin
+      class CopyableCoin < ActiveRecord::Base
+        copyable do
+          disable_all_callbacks_and_observers_except_validate
+          columns({
+            kind:  :copy,
+            year:  lambda { |orig| -444 },
+          })
+          associations({
+          })
+        end
+      end
+    end
+    it 'should raise an error if data is not valid' do
+      expect(CopyableCoin.count).to eq(0)
+      coin = CopyableCoin.create!(kind: 'cent', year: 1982)
+      expect {
+        coin.create_copy!
+      }.to raise_error(ActiveRecord::RecordInvalid)
+    end
+  end
+
+  context 'with :do_not_copy advice' do
+    before(:each) do
+      undefine_copyable_in CopyableCoin
+      class CopyableCoin < ActiveRecord::Base
+        copyable do
+          disable_all_callbacks_and_observers_except_validate
+          columns({
+            kind:  :do_not_copy,
+            year:  :copy,
+          })
+          associations({
+          })
+        end
+      end
+    end
+    it 'should result in a nil value for that column' do
+      expect(CopyableCoin.count).to eq(0)
+      coin = CopyableCoin.create!(kind: 'cent', year: 1982)
+      copied_coin = coin.create_copy!
+      expect(copied_coin.kind).to be_nil
+    end
+  end
+end

data/spec/copyable_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Copyable do
+  it 'has a version number' do
+    expect(Copyable::VERSION).not_to be nil
+  end
+end

data/spec/create_copy_spec.rb

@@ -0,0 +1,136 @@
+require_relative 'helper/copyable_spec_helper'
+
+describe 'create_copy!' do
+  before(:each) do
+    undefine_copyable_in CopyableCoin
+    class CopyableCoin < ActiveRecord::Base
+      copyable do
+        disable_all_callbacks_and_observers_except_validate
+        columns({
+          kind:  :copy,
+          year:  :copy,
+        })
+        associations({
+        })
+      end
+    end
+  end
+
+  it 'should exist' do
+    coin = CopyableCoin.create!(kind: 'cent', year: 1909)
+    expect(coin).to respond_to(:create_copy!)
+  end
+
+  it 'should create a new record' do
+    expect(CopyableCoin.count).to eq(0)
+    coin = CopyableCoin.create!(kind: 'cent', year: 1909)
+    coin.create_copy!
+    expect(CopyableCoin.count).to eq(2)
+  end
+
+  it 'should return the new record' do
+    expect(CopyableCoin.count).to eq(0)
+    coin = CopyableCoin.create!(kind: 'cent', year: 1909)
+    coin2 = coin.create_copy!
+    expect(coin2).to be_a CopyableCoin
+  end
+
+  it 'should return the new record having an id' do
+    expect(CopyableCoin.count).to eq(0)
+    coin = CopyableCoin.create!(kind: 'cent', year: 1909)
+    coin2 = coin.create_copy!
+    expect(coin2.id).not_to be_nil
+  end
+
+  it 'should allow columns to be overridden' do
+    expect(CopyableCoin.count).to eq(0)
+    coin = CopyableCoin.create!(kind: 'cent', year: 1909)
+    coin2 = coin.create_copy!(override: { year: 1959 })
+    expect(coin2.kind).to eq('cent')
+    expect(coin2.year).to eq(1959)
+  end
+
+  it 'should allow columns to be overridden using strings as column names' do
+    expect(CopyableCoin.count).to eq(0)
+    coin = CopyableCoin.create!('kind' => 'cent', 'year' => 1909)
+    coin2 = coin.create_copy!(override: { 'year' => 1959 })
+    expect(coin2.kind).to eq('cent')
+    expect(coin2.year).to eq(1959)
+  end
+
+  it 'should allow validations to be skipped' do
+    coin = CopyableCoin.create!('kind' => 'cent', 'year' => 1909)
+    expect {
+      coin.create_copy!(override: { 'year' => 2 })
+    }.to raise_error(ActiveRecord::RecordInvalid)
+    expect {
+      coin.create_copy!(override: { 'year' => 2 }, skip_validations: true)
+    }.to_not raise_error
+  end
+
+  it 'should skip validations even in associated objects when skip_validations is true' do
+    # set up classes
+    undefine_copyable_in CopyablePet
+    class CopyablePet < ActiveRecord::Base
+      copyable do
+        disable_all_callbacks_and_observers_except_validate
+        columns({
+          name:        :copy,
+          kind:        :copy,
+          birth_year:  :copy,
+        })
+        associations({
+          copyable_toys:                    :copy,
+          copyable_pet_tag:                 :do_not_copy,
+          copyable_pet_profile:             :do_not_copy,
+          copyable_pet_foods:               :do_not_copy,
+          copyable_pet_sitting_patronages:  :do_not_copy,
+        })
+      end
+    end
+
+    undefine_copyable_in CopyableToy
+    class CopyableToy < ActiveRecord::Base
+      copyable do
+        disable_all_callbacks_and_observers_except_validate
+        columns({
+          name:             :copy,
+          kind:             :copy,
+          copyable_pet_id:  :copy,
+        })
+        associations({
+        })
+      end
+    end
+
+    # set up objects
+    fido = CopyablePet.create!(
+     name: 'Fido',
+     kind: 'canine',
+     birth_year: 2005)
+
+    pillow = CopyableToy.create!(
+     name: 'favorite pillow',
+     kind: 'soft',
+     copyable_pet: fido)
+
+    # everything should be wonderful
+    expect {
+      fido.create_copy!
+    }.to_not raise_error
+
+    # now inject some invalid data in an associated object
+    pillow.update_column(:name, 'o')
+    fido.reload
+
+    # fail because invalid!
+    expect {
+      fido.create_copy!
+    }.to raise_error(ActiveRecord::RecordInvalid)
+
+    # oh quit complaning and do it anyway!
+    expect {
+      fido.create_copy!(skip_validations: true)
+    }.to_not raise_error
+  end
+end

data/spec/deep_structure_copy_spec.rb

@@ -0,0 +1,169 @@
+require_relative 'helper/copyable_spec_helper'
+
+describe 'complex model hierarchies:' do
+  before(:each) do
+    undefine_copyable_in CopyableOwner
+    class CopyableOwner < ActiveRecord::Base
+      copyable do
+        disable_all_callbacks_and_observers_except_validate
+        columns({
+          name:  :copy,
+        })
+        associations({
+          copyable_vehicles:  :copy,
+          copyable_amenities: :copy,
+        })
+      end
+    end
+    undefine_copyable_in CopyableVehicle
+    class CopyableVehicle < ActiveRecord::Base
+      copyable do
+        disable_all_callbacks_and_observers_except_validate
+        columns({
+          name:               :copy,
+          copyable_owner_id:  :copy,
+        })
+        associations({
+          copyable_amenities:  :copy,
+        })
+      end
+    end
+    undefine_copyable_in CopyableAmenity
+    class CopyableAmenity < ActiveRecord::Base
+      copyable do
+        disable_all_callbacks_and_observers_except_validate
+        columns({
+          name:                 :copy,
+          copyable_vehicle_id:  :copy,
+          copyable_owner_id:    :copy,
+        })
+        associations({
+          copyable_warranty:  :copy,
+        })
+      end
+    end
+    undefine_copyable_in CopyableWarranty
+    class CopyableWarranty < ActiveRecord::Base
+      copyable do
+        disable_all_callbacks_and_observers_except_validate
+        columns({
+          name:                 :copy,
+          copyable_amenity_id:  :copy,
+        })
+        associations({
+        })
+      end
+    end
+  end
+
+  describe 'a tree structure' do
+    before(:each) do
+      # We are avoiding using owners to avoid the denormalized aspect
+      # of the data model and keep this a simple tree.
+      @vehicle1 = CopyableVehicle.create!(name: 'Corvette')
+
+      @amenity1 = CopyableAmenity.create!(name: 'moon roof', copyable_vehicle: @vehicle1)
+      @warranty1 = CopyableWarranty.create!(name: 'moon roof warranty', copyable_amenity: @amenity1)
+      @amenity2 = CopyableAmenity.create!(name: 'twitter', copyable_vehicle: @vehicle1)
+      @warranty2 = CopyableWarranty.create!(name: 'twitter warranty', copyable_amenity: @amenity2)
+      @amenity3 = CopyableAmenity.create!(name: 'jazz', copyable_vehicle: @vehicle1)
+      @warranty3 = CopyableWarranty.create!(name: 'jazz warranty', copyable_amenity: @amenity3)
+    end
+
+    it 'should copy the entire tree as directed' do
+      @vehicle2 = @vehicle1.create_copy!
+      expect(CopyableVehicle.count).to eq(2)
+      expect(CopyableAmenity.count).to eq(6)
+      expect(CopyableWarranty.count).to eq(6)
+      expect(@vehicle2.name).to eq('Corvette')
+      expect(@vehicle2.copyable_amenities.map(&:name)).to match_array(
+       ['moon roof', 'twitter', 'jazz'])
+      expect(@vehicle2.copyable_amenities.map(&:copyable_warranty).map(&:name)).to match_array(
+       ['moon roof warranty', 'twitter warranty', 'jazz warranty'])
+    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!
+      expect(CopyableVehicle.count).to eq(2)
+      expect(CopyableAmenity.count).to eq(6)
+      expect(CopyableWarranty.count).to eq(6)
+      @vehicle1.create_copy!
+      expect(CopyableVehicle.count).to eq(3)
+      expect(CopyableAmenity.count).to eq(9)
+      expect(CopyableWarranty.count).to eq(9)
+      @vehicle1.create_copy!
+      expect(CopyableVehicle.count).to eq(4)
+      expect(CopyableAmenity.count).to eq(12)
+      expect(CopyableWarranty.count).to eq(12)
+    end
+  end
+
+  describe 'a denormalized structure' do
+    context 'having one redundant association' do
+      before(:each) do
+        @joe = CopyableOwner.create!(name: 'Joe')
+        @porsche = CopyableVehicle.create!(name: 'Porsche', copyable_owner: @joe)
+        @moon_roof = CopyableAmenity.create!(name: 'moon roof',
+                                             copyable_vehicle: @porsche,
+                                             copyable_owner: @joe)
+      end
+
+      it 'should copy the records without copying any given record more than once' do
+        @copy_of_joe = @joe.create_copy!
+        expect(CopyableOwner.count).to eq(2)
+        expect(CopyableVehicle.count).to eq(2)
+        expect(CopyableAmenity.count).to eq(2)
+      end
+    end
+
+    context 'with many models, some having redundant associations' do
+      before(:each) do
+        @joe = CopyableOwner.create!(name: 'Joe')
+
+        @porsche = CopyableVehicle.create!(name: 'Porsche', copyable_owner: @joe)
+        @moon_roof = CopyableAmenity.create!(
+          name: 'moon roof',
+          copyable_vehicle: @porsche,
+          copyable_owner: @joe)
+
+        @mustang = CopyableVehicle.create!(name: 'Mustang', copyable_owner: @joe)
+        @air_conditioning = CopyableAmenity.create!(
+          name: 'air conditioning',
+          copyable_vehicle: @mustang,
+          copyable_owner: @joe)
+        @air_conditioning_warranty = CopyableWarranty.create!(
+          name: 'air conditioning warranty',
+          copyable_amenity: @air_conditioning)
+
+        @corvette = CopyableVehicle.create!(name: 'Corvette', copyable_owner: @joe)
+        @pillows = CopyableAmenity.create!(
+          name: 'pillows',
+          copyable_vehicle: @corvette,
+          copyable_owner: @joe)
+        @pillow_warranty = CopyableWarranty.create!(name: 'pillow warranty', copyable_amenity: @pillows)
+        @airbags = CopyableAmenity.create!(
+          name: 'airbags',
+          copyable_vehicle: @corvette,
+          copyable_owner: @joe)
+        @airbag_warranty = CopyableWarranty.create!(name: 'airbag warranty', copyable_amenity: @airbags)
+        @radio = CopyableAmenity.create!(
+          name: 'satellite radio',
+          copyable_vehicle: @corvette,
+          copyable_owner: @joe)
+      end
+
+      it 'should copy the records without copying any given record more than once' do
+        @copy_of_joe = @joe.create_copy!
+        expect(CopyableOwner.count).to eq(2)
+        expect(CopyableVehicle.count).to eq(6)
+        expect(CopyableAmenity.count).to eq(10)
+        expect(CopyableWarranty.count).to eq(6)
+        expect(@copy_of_joe.copyable_vehicles.map(&:name)).to match_array([
+          'Porsche', 'Mustang', 'Corvette'])
+        expect(@copy_of_joe.copyable_amenities.map(&:name)).to match_array([
+          'moon roof', 'air conditioning', 'pillows', 'airbags', 'satellite radio'])
+      end
+    end
+  end
+end

data/spec/helper/copyable_spec_helper.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+# copyable needs its own set of tables and ActiveRecord models to test with.
+require_relative 'test_tables'
+Copyable::TestTables.create!
+require_relative 'test_models'
+
+# useful for starting off specs with a clean slate
+def undefine_copyable_in(klass)
+  klass.instance_eval do
+    define_method(:create_copy!) do |*args|
+      raise "the create_copy! method has been wiped clean for testing purposes"
+    end
+  end
+end

data/spec/helper/test_models.rb

@@ -0,0 +1,136 @@
+# We need various test models in various configurations to properly test the
+# copying functionality.
+
+
+#*******************************************************************************
+#  For testing basic copying behavior and validation.
+#
+
+class CopyableCoin < ActiveRecord::Base
+  validates :year, numericality: { greater_than: 1700 }
+end
+
+
+
+#*******************************************************************************
+#  For testing observers.
+#
+
+class CopyableCar < ActiveRecord::Base
+  validates :make, presence: true
+  validates :model, presence: true
+  validates :year, presence: true
+end
+
+
+
+#*******************************************************************************
+#  For testing callbacks.
+#
+
+class CopyableTree < ActiveRecord::Base
+  after_create  :callback1
+  before_save   { |tree| raise "callback2 called" }
+  def callback1
+    raise "callback1 called"
+  end
+end
+
+
+
+#*******************************************************************************
+#  For testing basic associations.
+#
+
+class CopyablePet < ActiveRecord::Base
+  has_many :copyable_toys
+  has_one :copyable_pet_tag
+  has_one :copyable_pet_profile
+  has_one :copyable_address, through: :copyable_pet_profile
+  # Rails 3 expects the join table to be called copyable_pet_foods_copyable_pets
+  # Rails 4 expects the join table to be called copyable_pet_foods_pets
+  # We explicitly name the join table so that this code works with both Rails 3 and Rails 4.
+  has_and_belongs_to_many :copyable_pet_foods, join_table: 'copyable_pet_foods_pets'
+  has_many :copyable_pet_sitting_patronages
+  has_many :copyable_pet_sitters, through: :copyable_pet_sitting_patronages
+end
+
+class CopyableToy < ActiveRecord::Base
+  validates  :name, length: { minimum: 3 }
+  belongs_to :copyable_pet
+end
+
+class CopyablePetTag < ActiveRecord::Base
+  belongs_to :copyable_pet
+end
+
+class CopyablePetFood < ActiveRecord::Base
+  # Rails 3 expects the join table to be called copyable_pet_foods_copyable_pets
+  # Rails 4 expects the join table to be called copyable_pet_foods_pets
+  # We explicitly name the join table so that this code works with both Rails 3 and Rails 4.
+  has_and_belongs_to_many :copyable_pets, join_table: 'copyable_pet_foods_pets'
+end
+
+class CopyablePetSitter < ActiveRecord::Base
+  has_many :copyable_pet_sitting_patronages
+  has_many :copyable_pets, through: :copyable_pet_sitting_patronages
+end
+
+class CopyablePetSittingPatronage < ActiveRecord::Base
+  belongs_to :copyable_pet
+  belongs_to :copyable_pet_sitter
+end
+
+class CopyablePetProfile < ActiveRecord::Base
+  belongs_to :copyable_pet
+  has_one :copyable_address
+end
+
+class CopyableAddress < ActiveRecord::Base
+  belongs_to :copyable_pet_profile
+end
+
+
+
+#*******************************************************************************
+#  For testing polymorphic associations and custom-named foreign keys.
+#
+
+class CopyablePicture < ActiveRecord::Base
+  belongs_to :imageable, polymorphic: true
+  belongs_to :copyable_album, foreign_key: 'picture_album_id'
+end
+
+class CopyableProduct < ActiveRecord::Base
+  has_many :copyable_pictures, as: :imageable
+end
+
+class CopyableAlbum < ActiveRecord::Base
+  has_many :copyable_pictures, foreign_key: 'picture_album_id'
+end
+
+
+
+#*******************************************************************************
+#  For testing denormalized data structures.
+#
+
+class CopyableOwner < ActiveRecord::Base
+  has_many :copyable_vehicles
+  has_many :copyable_amenities  # this is not normalized, you wouldn't normally do this
+end
+
+class CopyableVehicle < ActiveRecord::Base
+  has_many :copyable_amenities
+  belongs_to  :copyable_owner
+end
+
+class CopyableAmenity < ActiveRecord::Base
+  belongs_to :copyable_vehicle
+  belongs_to :copyable_owner  # this is not normalized, you wouldn't normally do this
+  has_one :copyable_warranty
+end
+
+class CopyableWarranty < ActiveRecord::Base
+  belongs_to :copyable_amenity
+end