amoeba 3.0.0 → 3.1.0

data/lib/amoeba/class_methods.rb

@@ -16,6 +16,11 @@ module Amoeba
       @config
     end
 
+    def reset_amoeba(&block)
+      @config_block = block if block_given?
+      @config = Amoeba::Config.new(self)
+    end
+
     def amoeba_block
       @config_block
     end

data/lib/amoeba/cloner.rb

@@ -9,10 +9,11 @@ module Amoeba
     def_delegators :old_object, :_parent_amoeba, :_amoeba_settings,
                    :_parent_amoeba_settings
 
-    def_delegators :object_klass, :amoeba, :fresh_amoeba
+    def_delegators :object_klass, :amoeba, :fresh_amoeba, :reset_amoeba
 
     def initialize(object, options = {})
-      @old_object, @options = object, options
+      @old_object = object
+      @options    = options
       @object_klass = @old_object.class
       inherit_parent_settings
       @new_object = object.__send__(amoeba.dup_method)
@@ -40,12 +41,13 @@ module Amoeba
     end
 
     def inherit_submissive_parent_settings
-      fresh_amoeba(&_parent_amoeba_settings)
+      reset_amoeba(&_amoeba_settings)
+      amoeba(&_parent_amoeba_settings)
       amoeba(&_amoeba_settings)
     end
 
     def inherit_parent_settings
-      return if amoeba.enabled || !_parent_amoeba.inherit
+      return if !_parent_amoeba.inherit
       return unless %w(strict relaxed submissive).include?(parenting_style.to_s)
       __send__("inherit_#{parenting_style}_parent_settings".to_sym)
     end
@@ -64,19 +66,21 @@ module Amoeba
       # table from copying so we don't end up with the new
       # and old children on the copy
       return unless association.macro == :has_many ||
-        association.is_a?(::ActiveRecord::Reflection::ThroughReflection)
+                    association.is_a?(::ActiveRecord::Reflection::ThroughReflection)
       amoeba.exclude_association(association.options[:through])
     end
 
     def follow_only_includes
-      amoeba.includes.each do |include|
+      amoeba.includes.each do |include, options|
+        next if options[:if] && !@old_object.send(options[:if])
         follow_association(include, @object_klass.reflect_on_association(include))
       end
     end
 
     def follow_all_except_excludes
       @object_klass.reflections.each do |name, association|
-        next if amoeba.excludes.include?(name.to_sym)
+        exclude = amoeba.excludes[name.to_sym]
+        next if exclude && (exclude.blank? || @old_object.send(exclude[:if]))
         follow_association(name, association)
       end
     end
@@ -88,9 +92,9 @@ module Amoeba
     end
 
     def apply_associations
-      if amoeba.includes.size > 0
+      if amoeba.includes.present?
         follow_only_includes
-      elsif amoeba.excludes.size > 0
+      elsif amoeba.excludes.present?
         follow_all_except_excludes
       else
         follow_all
@@ -110,7 +114,7 @@ module Amoeba
 
     def process_overrides
       amoeba.overrides.each do |block|
-        block.call(@new_object, @new_object)
+        block.call(@old_object, @new_object)
       end
     end
 
@@ -124,7 +128,7 @@ module Amoeba
     def process_coercions
       # prepend any extra strings to indicate uniqueness of the new record(s)
       amoeba.coercions.each do |field, coercion|
-        @new_object[field] = "#{coercion}"
+        @new_object[field] = coercion.to_s
       end
     end
 

data/lib/amoeba/config.rb

@@ -8,8 +8,8 @@ module Amoeba
       raised:         false,
       dup_method:     :dup,
       remap_method:   nil,
-      includes:       [],
-      excludes:       [],
+      includes:       {},
+      excludes:       {},
       clones:         [],
       customizations: [],
       overrides:      [],
@@ -40,7 +40,7 @@ module Amoeba
     DEFAULTS.freeze
 
     DEFAULTS.each do |key, value|
-      value.freeze
+      value.freeze if value.is_a?(Array) || value.is_a?(Hash)
       class_eval <<-EOS, __FILE__, __LINE__ + 1
         def #{key}          # def enabled
           @config[:#{key}]  #   @config[:enabled]
@@ -69,15 +69,15 @@ module Amoeba
 
     def propagate(style = :submissive)
       @config[:parenting] ||= style
-      @config[:inherit]  = true
+      @config[:inherit] = true
     end
 
     def push_value_to_array(value, key)
       res = @config[key]
       if value.is_a?(::Array)
         res = value
-      else
-        res << value if value
+      elsif value
+        res << value
       end
       @config[key] = res.uniq
     end
@@ -107,37 +107,45 @@ module Amoeba
       @config[config_key][key] = val if val || (!val.nil? && config_key == :coercions)
     end
 
-    def include_association(value = nil)
-      @config[:enabled]  = true
-      @config[:excludes] = []
-      push_value_to_array(value, :includes)
+    def include_association(value = nil, options = {})
+      enable
+      @config[:excludes] = {}
+      push_value_to_hash({ value => options }, :includes)
+    end
+
+    def include_associations(*values)
+      values.flatten.each { |v| include_association(v) }
     end
 
-    # TODO remove this method in v3.0.0
+    # TODO: remove this method in v3.0.0
     def include_field(value = nil)
-      warn "include_field is deprecated and will be removed in version 3.0.0; please use include_association instead"
+      warn 'include_field is deprecated and will be removed in version 3.0.0; please use include_association instead'
       include_association(value)
     end
 
-    def exclude_association(value = nil)
-      @config[:enabled]  = true
-      @config[:includes] = []
-      push_value_to_array(value, :excludes)
+    def exclude_association(value = nil, options = {})
+      enable
+      @config[:includes] = {}
+      push_value_to_hash({ value => options }, :excludes)
     end
 
-    # TODO remove this method in v3.0.0
+    def exclude_associations(*values)
+      values.flatten.each { |v| exclude_association(v) }
+    end
+
+    # TODO: remove this method in v3.0.0
     def exclude_field(value = nil)
-      warn "exclude_field is deprecated and will be removed in version 3.0.0; please use exclude_association instead"
+      warn 'exclude_field is deprecated and will be removed in version 3.0.0; please use exclude_association instead'
       exclude_association(value)
     end
 
     def clone(value = nil)
-      @config[:enabled] = true
+      enable
       push_value_to_array(value, :clones)
     end
 
     def recognize(value = nil)
-      @config[:enabled] = true
+      enable
       push_value_to_array(value, :known_macros)
     end
 

data/lib/amoeba/version.rb

@@ -1,3 +1,3 @@
 module Amoeba
-  VERSION = '3.0.0'
+  VERSION = '3.1.0'
 end

data/spec/lib/amoeba_spec.rb

@@ -5,6 +5,9 @@ describe 'amoeba' do
     before :each do
       require ::File.dirname(__FILE__) + '/../support/data.rb'
     end
+
+    let(:first_product) { Product.find(1) }
+
     it 'duplicates associated child records' do
       # Posts {{{
       old_post = ::Post.find(1)
@@ -29,18 +32,16 @@ describe 'amoeba' do
       start_postconfig_count = PostConfig.all.count
       start_postwidget_count = PostWidget.all.count
       start_superkitten_count = Superkitten.all.count
-      rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS tag_count FROM posts_tags')
-      start_posttag_count = rs['tag_count']
-      rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS note_count FROM notes_posts')
-      start_postnote_count = rs['note_count']
+      start_posttag_count = Post.tag_count
+      start_postnote_count = Post.note_count
 
       expect(new_post.save!).to be_truthy
       expect(new_post.title).to eq("Copy of #{old_post.title}")
 
-      end_account_count = Account.all.count
-      end_history_count = History.all.count
-      end_cat_count = Category.all.count
-      end_supercat_count = Supercat.all.count
+      end_account_count = Account.count
+      end_history_count = History.count
+      end_cat_count = Category.count
+      end_supercat_count = Supercat.count
       end_tag_count = Tag.all.count
       end_note_count = Note.all.count
       end_widget_count = Widget.all.count
@@ -50,10 +51,8 @@ describe 'amoeba' do
       end_postconfig_count = PostConfig.all.count
       end_postwidget_count = PostWidget.all.count
       end_superkitten_count = Superkitten.all.count
-      rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS tag_count FROM posts_tags')
-      end_posttag_count = rs['tag_count']
-      rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS note_count FROM notes_posts')
-      end_postnote_count = rs['note_count']
+      end_posttag_count = Post.tag_count
+      end_postnote_count = Post.note_count
 
       expect(end_tag_count).to         eq(start_tag_count)
       expect(end_cat_count).to         eq(start_cat_count)
@@ -71,9 +70,9 @@ describe 'amoeba' do
       expect(end_postnote_count).to    eq(start_postnote_count * 2)
       expect(end_superkitten_count).to eq(start_superkitten_count * 2)
 
-      expect(new_post.supercats.map(&:ramblings).include?('Copy of zomg')).to be true
+      expect(new_post.supercats.map(&:ramblings)).to include('Copy of zomg')
       expect(new_post.supercats.map(&:other_ramblings).uniq.length).to eq(1)
-      expect(new_post.supercats.map(&:other_ramblings).uniq.include?('La la la')).to be true
+      expect(new_post.supercats.map(&:other_ramblings).uniq).to include('La la la')
       expect(new_post.contents).to eq("Here's a copy: #{old_post.contents.gsub(/dog/, 'cat')} (copied version)")
       expect(new_post.comments.length).to eq(5)
       expect(new_post.comments.select { |c| c.nerf == 'ratatat' && c.contents.nil? }.length).to eq(1)
@@ -82,7 +81,7 @@ describe 'amoeba' do
       expect(new_post.comments.select { |c| c.nerf == 'bonkers' && c.contents.nil? }.length).to eq(1)
 
       new_post.widgets.map(&:id).each do |id|
-        expect(old_post.widgets.map(&:id).include?(id)).not_to be true
+        expect(old_post.widgets.map(&:id)).not_to include(id)
       end
 
       expect(new_post.custom_things.length).to eq(3)
@@ -94,7 +93,7 @@ describe 'amoeba' do
       old_author = Author.find(1)
       new_author = old_author.amoeba_dup
       new_author.save!
-      expect(new_author.errors.messages.length).to eq(0)
+      expect(new_author.errors.messages).to be_empty
       expect(new_author.posts.first.custom_things.length).to eq(3)
       expect(new_author.posts.first.custom_things.select { |ct| ct.value == [] }.length).to eq(1)
       expect(new_author.posts.first.custom_things.select { |ct| ct.value == [1, 2] }.length).to eq(1)
@@ -102,24 +101,20 @@ describe 'amoeba' do
       # }}}
       # Products {{{
       # Base Class {{{
-      old_product = Product.find(1)
 
-      start_image_count = Image.where(product_id: old_product.id).count
+      start_image_count = first_product.images.count
       start_section_count = Section.all.length
-      rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', old_product.id)
-      start_prodsection_count = rs['section_count']
+      start_prodsection_count = first_product.section_count
 
-      new_product = old_product.amoeba_dup
+      new_product = first_product.amoeba_dup
       new_product.save
-      expect(new_product.errors.messages.length).to eq(0)
+      expect(new_product.errors.messages).to be_empty
 
-      end_image_count = Image.where(product_id: old_product.id).count
-      end_newimage_count = Image.where(product_id: new_product.id).count
+      end_image_count = first_product.images.count
+      end_newimage_count = new_product.images.count
       end_section_count = Section.all.length
-      rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', 1)
-      end_prodsection_count = rs['section_count']
-      rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', new_product.id)
-      end_newprodsection_count = rs['section_count']
+      end_prodsection_count = first_product.section_count
+      end_newprodsection_count = new_product.section_count
 
       expect(end_image_count).to eq(start_image_count)
       expect(end_newimage_count).to eq(start_image_count)
@@ -132,22 +127,19 @@ describe 'amoeba' do
       # Shirt {{{
       old_product = Shirt.find(2)
 
-      start_image_count = Image.where(product_id: old_product.id).count
-      start_section_count = Section.all.length
-      rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', old_product.id)
-      start_prodsection_count = rs['section_count']
+      start_image_count = old_product.images.count
+      start_section_count = Section.count
+      start_prodsection_count = old_product.section_count
 
       new_product = old_product.amoeba_dup
       new_product.save
-      expect(new_product.errors.messages.length).to eq(0)
+      expect(new_product.errors.messages).to be_empty
 
-      end_image_count = Image.where(product_id: old_product.id).count
-      end_newimage_count = Image.where(product_id: new_product.id).count
-      end_section_count = Section.all.length
-      rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', 1)
-      end_prodsection_count = rs['section_count']
-      rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', new_product.id)
-      end_newprodsection_count = rs['section_count']
+      end_image_count = old_product.images.count
+      end_newimage_count = new_product.images.count
+      end_section_count = Section.count
+      end_prodsection_count = first_product.section_count
+      end_newprodsection_count = new_product.section_count
 
       expect(end_image_count).to eq(start_image_count)
       expect(end_newimage_count).to eq(start_image_count)
@@ -159,22 +151,19 @@ describe 'amoeba' do
       # Necklace {{{
       old_product = Necklace.find(3)
 
-      start_image_count = Image.where(product_id: old_product.id).count
-      start_section_count = Section.all.length
-      rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', old_product.id)
-      start_prodsection_count = rs['section_count']
+      start_image_count = old_product.images.count
+      start_section_count = Section.count
+      start_prodsection_count = old_product.section_count
 
       new_product = old_product.amoeba_dup
       new_product.save
-      expect(new_product.errors.messages.length).to eq(0)
+      expect(new_product.errors.messages).to be_empty
 
-      end_image_count = Image.where(product_id: old_product.id).count
-      end_newimage_count = Image.where(product_id: new_product.id).count
-      end_section_count = Section.all.length
-      rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', 1)
-      end_prodsection_count = rs['section_count']
-      rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS section_count FROM products_sections WHERE product_id = ?', new_product.id)
-      end_newprodsection_count = rs['section_count']
+      end_image_count = old_product.images.count
+      end_newimage_count = new_product.images.count
+      end_section_count = Section.count
+      end_prodsection_count = first_product.section_count
+      end_newprodsection_count = new_product.section_count
 
       expect(end_image_count).to eq(start_image_count)
       expect(end_newimage_count).to eq(start_image_count)
@@ -186,23 +175,60 @@ describe 'amoeba' do
       # }}}
     end
   end
+
+  context 'use if condition in includes and excludes' do
+    before(:all) do
+      require ::File.dirname(__FILE__) + '/../support/data.rb'
+    end
+    before { ::Post.fresh_amoeba }
+
+    subject { post.amoeba_dup.save! }
+    let(:post) { Post.first }
+
+    it 'includes associations with truthy condition' do
+      ::Post.amoeba do
+        include_association :comments, if: :truthy?
+      end
+      expect { subject }.to change { Comment.count }.by(3)
+    end
+
+    it 'does not include associations with false condition' do
+      ::Post.amoeba do
+        include_association :comments, if: :falsey?
+      end
+      expect { subject }.not_to change { Comment.count }
+    end
+
+    it 'excludes associations with truthy condition' do
+      ::Post.amoeba do
+        exclude_association :comments, if: :truthy?
+      end
+      expect { subject }.not_to change { Comment.count }
+    end
+
+    it 'does not exclude associations with false condition' do
+      ::Post.amoeba do
+        exclude_association :comments, if: :falsey?
+      end
+      expect { subject }.to change { Comment.count }.by(3)
+    end
+  end
+
   context 'override' do
     before :each do
       ::Image.fresh_amoeba
       ::Image.amoeba do
-        override ->(old, new) {
-          if old.filename == 'test.jpg'
-            new.product_id = 13
-          end
-        }
+        override ->(old, new) { new.product_id = 13 if old.filename == 'test.jpg' }
       end
     end
+
     it 'should override fields' do
       image = ::Image.create(filename: 'test.jpg', product_id: 12)
       image_dup = image.amoeba_dup
       expect(image_dup.save).to be_truthy
       expect(image_dup.product_id).to eq(13)
     end
+
     it 'should not override fields' do
       image = ::Image.create(filename: 'test2.jpg', product_id: 12)
       image_dup = image.amoeba_dup
@@ -218,17 +244,19 @@ describe 'amoeba' do
         nullify :product_id
       end
     end
+
+    let(:image) { ::Image.create(filename: 'test.jpg', product_id: 12) }
+    let(:image_dup) { image.amoeba_dup }
+
     it 'should nullify fields' do
-      image = ::Image.create(filename: 'test.jpg', product_id: 12)
-      image_dup = image.amoeba_dup
       expect(image_dup.save).to be_truthy
       expect(image_dup.product_id).to be_nil
     end
   end
 
   context 'strict propagate' do
-    it 'should call #fresh_amoeba' do
-      expect(::SuperBlackBox).to receive(:fresh_amoeba).and_call_original
+    it 'should call #reset_amoeba' do
+      expect(::SuperBlackBox).to receive(:reset_amoeba).and_call_original
       box = ::SuperBlackBox.create(title: 'Super Black Box', price: 9.99, length: 1, metal: '1')
       new_box = box.amoeba_dup
       expect(new_box.save).to be_truthy
@@ -237,12 +265,14 @@ describe 'amoeba' do
 
   context 'remapping and custom dup method' do
     let(:prototype) { ObjectPrototype.new }
+
     context 'through' do
       it do
         real_object = prototype.amoeba_dup
         expect(real_object).to be_a(::RealObject)
       end
     end
+
     context 'remapper' do
       it do
         prototype.subobject_prototypes << SubobjectPrototype.new
@@ -253,29 +283,94 @@ describe 'amoeba' do
   end
 
   context 'preprocessing fields' do
+    subject { super_admin.amoeba_dup }
+    let(:super_admin) { ::SuperAdmin.create!(email: 'user@example.com', active: true, password: 'password') }
+
     it 'should accept "set" to set false to attribute' do
-      super_admin = ::SuperAdmin.create!(email: 'user@example.com', active: true, password: 'password')
-      clone = super_admin.amoeba_dup
-      expect(clone.active).to eq(false)
+      expect(subject.active).to be false
     end
+
     it 'should skip "prepend" if it equal to false' do
-      super_admin = ::SuperAdmin.create!(email: 'user2@example.com', active: true, password: 'password')
-      clone = super_admin.amoeba_dup
-      expect(clone.password).to eq('password')
+      expect(subject.password).to eq('password')
     end
   end
 
   context 'inheritance' do
+    let(:box) { Box.create }
+
     it 'does not fail with a deep inheritance' do
-      box = Box.create
       sub_sub_product = BoxSubSubProduct.create(title: 'Awesome shoes')
       another_product = BoxAnotherProduct.create(title: 'Cleaning product')
-      sub_sub_product.box = box
-      sub_sub_product.another_product = another_product
-      sub_sub_product.save
+      sub_sub_product.update_attributes(box: box, another_product: another_product)
       expect(box.sub_products.first.another_product.title).to eq('Cleaning product')
       expect(box.amoeba_dup.sub_products.first.another_product.title).to eq('Cleaning product')
     end
   end
 
+  context 'inheritance extended' do
+    let(:stage) do
+      stage = CustomStage.new(title: 'My Stage', external_id: 213)
+      stage.listeners.build(name: 'John')
+      stage.listeners.build(name: 'Helen')
+      stage.specialists.build(name: 'Jack')
+      stage.custom_rules.build(description: 'Kill all humans')
+      stage.save!
+      stage
+    end
+
+    subject { stage.amoeba_dup }
+
+    it "contains parent association and own associations", :aggregate_failures do
+      subject
+      expect { subject.save! }.to change(Listener, :count).by(2).
+                                  and change(Specialist, :count).by(1).
+                                  and change(CustomRule, :count).by(1)
+
+      expect(subject.title).to eq 'My Stage'
+      expect(subject.external_id).to be_nil
+      expect(subject.listeners.find_by(name: 'John')).to_not be_nil
+      expect(subject.listeners.find_by(name: 'Helen')).to_not be_nil
+      expect(subject.specialists.find_by(name: 'Jack')).to_not be_nil
+      expect(subject.custom_rules.first.description).to eq 'Kill all humans'
+    end
+  end
+
+  context 'polymorphic' do
+    let(:company) { Company.find_by(name: 'ABC Industries') }
+    let(:new_company) { company.amoeba_dup }
+
+    it 'does not fail with a deep inheritance' do
+      # employee = company.employees.where(name:'Joe').first
+      start_company_count = Company.count
+      start_customer_count = Customer.count
+      start_employee_count = Employee.count
+      start_address_count = Address.count
+      start_photo_count = Photo.count
+      new_company.name = "Copy of #{new_company.name}"
+      new_company.save
+      expect(Company.count).to eq(start_company_count + 1)
+      expect(Customer.count).to eq(start_customer_count + 1)
+      expect(Employee.count).to eq(start_employee_count + 1)
+      expect(Address.count).to eq(start_address_count + 4)
+      expect(Photo.count).to eq(start_photo_count + 2)
+
+      new_company.reload # fully reload from database
+      new_company_employees = new_company.employees
+      expect(new_company_employees.count).to eq(1)
+      new_company_employee_joe = new_company_employees.find_by(name: 'Joe')
+      expect(new_company_employee_joe.photos.count).to eq(1)
+      expect(new_company_employee_joe.photos.first.size).to eq(12_345)
+      expect(new_company_employee_joe.addresses.count).to eq(2)
+      expect(new_company_employee_joe.addresses.where(street: '123 My Street').count).to eq(1)
+      expect(new_company_employee_joe.addresses.where(street: '124 My Street').count).to eq(1)
+      new_company_customers = new_company.customers
+      expect(new_company_customers.count).to eq(1)
+      new_company_customer_my = new_company_customers.where(email: 'my@email.address').first
+      expect(new_company_customer_my.photos.count).to eq(1)
+      expect(new_company_customer_my.photos.first.size).to eq(54_321)
+      expect(new_company_customer_my.addresses.count).to eq(2)
+      expect(new_company_customer_my.addresses.where(street: '321 My Street').count).to eq(1)
+      expect(new_company_customer_my.addresses.where(street: '321 My Drive').count).to eq(1)
+    end
+  end
 end