amoeba 1.1.0 → 1.2.0

data/README.md

@@ -4,11 +4,21 @@ Easy copying of rails associations such as `has_many`.
 
 ![amoebalogo](http://rocksolidwebdesign.com/wp_cms/wp-content/uploads/2012/02/amoeba_logo.jpg)
 
-## Background
+## Installation
+
+is hopefully as you would expect:
+
+    gem install amoeba
+
+or just add it to your Gemfile:
+
+    gem 'amoeba'
+
+## What?
 
 The goal was to be able to easily and quickly reproduce ActiveRecord objects including their children, for example copying a blog post maintaining its associated tags or categories.
 
-I named this gem "Amoeba" because amoebas are (small life forms that are) good at reproducing. Their children and grandchildren also reproduce themselves quickly and easily.
+This gem is named "Amoeba" because amoebas are (small life forms that are) good at reproducing. Their children and grandchildren also reproduce themselves quickly and easily.
 
 ## Details
 
@@ -24,11 +34,12 @@ Rails 3.2 compatible.
     - `has_many :through`
     - `has_and_belongs_to_many`
 - A simple DSL for configuration of which fields to copy. The DSL can be applied to your rails models or used on the fly.
+- Supports STI (Single Table Inheritance) children inheriting their parent amoeba settings.
 - Multiple configuration styles such as inclusive, exclusive and indiscriminate (aka copy everything).
 - Supports cloning of the children of Many-to-Many records or merely maintaining original associations
-- Supports recursive copying of child and grandchild records.
+- Supports automatic drill-down i.e. recursive copying of child and grandchild records.
 - Supports preprocessing of fields to help indicate uniqueness and ensure the integrity of your data depending on your business logic needs, e.g. prepending "Copy of " or similar text.
-- Supports preprocessing of fields with custom lambda blocks so you can basically whatever you want, for example if you need some custom logic while making copies.
+- Supports preprocessing of fields with custom lambda blocks so you can do basically whatever you want if, for example, you need some custom logic while making copies.
 - Amoeba can perform the following preprocessing operations on fields of copied records
     - set
     - prepend
@@ -37,16 +48,6 @@ Rails 3.2 compatible.
     - customize
     - regex
 
-## Installation
-
-is hopefully as you would expect:
-
-    gem install amoeba
-
-or just add it to your Gemfile:
-
-    gem 'amoeba'
-
 ## Usage
 
 Configure your models with one of the styles below and then just run the `dup` method on your model as you normally would:
@@ -155,6 +156,8 @@ You may also specify fields to be copied by passing an array. If you call the `i
 
 These examples will copy the post's tags and authors but not its comments.
 
+The inclusive style, when used, will automatically disable any ther style that was previously selected.
+
 ### Exclusive Style
 
 If you have more fields to include than to exclude, you may wish to shorten the amount of typing and reading you need to do by using the exclusive style. All fields that are not explicitly excluded will be copied:
@@ -175,6 +178,8 @@ If you have more fields to include than to exclude, you may wish to shorten the
 
 This example does the same thing as the inclusive style example, it will copy the post's tags and authors but not its comments. As with inclusive style, there is no need to explicitly enable amoeba when specifying fields to exclude.
 
+The exclusive style, when used, will automatically disable any other style that was previously selected, so if you selected include fields, and then you choose some exclude fields, the `exclude_field` method will disable the previously slected inclusive style and wipe out any corresponding include fields.
+
 ### Cloning
 
 If you are using a Many-to-Many relationship, you may tell amoeba to actually make duplicates of the original related records rather than merely maintaining association with the original records. Cloning is easy, merely tell amoeba which fields to clone in the same way you tell it which fields to include or exclude.
@@ -207,6 +212,188 @@ If you are using a Many-to-Many relationship, you may tell amoeba to actually ma
 
 This example will actually duplicate the warnings and widgets in the database. If there were originally 3 warnings in the database then, upon duplicating a post, you will end up with 6 warnings in the database. This is in contrast to the default behavior where your new post would merely be re-associated with any previously existing warnings and those warnings themselves would not be duplicated.
 
+## Inheritance
+
+If you are using the Single Table Inheritance provided by ActiveRecord, you may cause amoeba to automatically process child classes in the same way as their parents. All you need to do is call the `propagate` method within the amoeba block of the parent class and all child classes should copy in a similar manner.
+
+    create_table :products, :force => true do |t|
+      t.string :type # this is the STI column
+
+      # these belong to all products
+      t.string :title
+      t.decimal :price
+
+      # these are for shirts only
+      t.decimal :sleeve_length
+      t.decimal :collar_size
+
+      # these are for computers only
+      t.integer :ram_size
+      t.integer :hard_drive_size
+    end
+
+    class Product < ActiveRecord::Base
+      has_many :images
+      has_and_belongs_to_many :categories
+
+      amoeba do
+        enable
+        propagate
+      end
+    end
+
+    class Shirt < Product
+    end
+
+    class Computer < Product
+    end
+
+    class ProductsController
+      def some_method
+        my_shirt = Shirt.find(1)
+        my_shirt.dup
+        my_shirt.save
+
+        # this shirt should now:
+        # - have its own copy of all parent images
+        # - be in the same categories as the parent
+      end
+    end
+
+This example should duplicate all the images and sections associated with this Shirt, which is a child of Product
+
+### Parenting Style
+
+By default, propagation uses submissive parenting, meaning the config settings on the parent will be applied, but any child settings, if present, will either add to or overwrite the parent settings depending on how you call the DSL methods.
+
+You may change this behavior, the so called "parenting style", to give preference to the parent settings or to ignore any and all child settings.
+
+#### Relaxed Parenting
+
+The `:relaxed` parenting style will prefer parent settings.
+
+    class Product < ActiveRecord::Base
+      has_many :images
+      has_and_belongs_to_many :sections
+
+      amoeba do
+        exclude_field :images
+        propagate :relaxed
+      end
+    end
+
+    class Shirt < Product
+      include_field :images
+      include_field :sections
+      prepend :title => "Copy of "
+    end
+
+In this example, the conflicting `include_field` settings on the child will be ignored and the parent `exclude_field` setting will be used, while the `prepend` setting on the child will be honored because it doesn't conflict with the parent.
+
+#### Strict Parenting
+
+The `:strict` style will ignore child settings altogether and inherit any parent settings.
+
+    class Product < ActiveRecord::Base
+      has_many :images
+      has_and_belongs_to_many :sections
+
+      amoeba do
+        exclude_field :images
+        propagate :strict
+      end
+    end
+
+    class Shirt < Product
+      include_field :images
+      include_field :sections
+      prepend :title => "Copy of "
+    end
+
+In this example, the only processing that will happen when a Shirt is duplicated is whatever processing is allowed by the parent. So in this case the parent's `exclude_field` directive takes precedence over the child's `include_field` settings, and not only that, but none of the other settings for the child are used either. The `prepend` setting of the child is completely ignored.
+
+#### Parenting and Precedence
+
+Because of the two general forms of DSL config parameter usage, you may wish to make yourself mindful of how your coding style will affect the outcome of duplicating an object.
+
+Just remember that:
+
+* If you pass an array you will wipe all previous settings
+* If you pass single values, you will add to currently existing settings
+
+This means that, for example:
+
+* When using the submissive parenting style, you can child take full precedence on a per field basis by passing an array of config values. This will cause the setting from the parent to be overridden instead of added to.
+* When using the relaxed parenting style, you can still let the parent take precedence on a per field basis by passing an array of config values. This will cause the setting for that child to be overridden instead of added to.
+
+#### A Submissive Override Example
+
+This version will use both the parent and child settings, so both the images and sections will be copied.
+
+    class Product < ActiveRecord::Base
+      has_many :images
+      has_and_belongs_to_many :sections
+
+      amoeba do
+        include_field :images
+        propagate
+      end
+    end
+
+    class Shirt < Product
+      include_field :sections
+    end
+
+The next version will use only the child settings because passing an array will override any previous settings rather than adding to them and the child config takes precedence in the `submissive` parenting style. So in this case only the sections will be copied.
+
+    class Product < ActiveRecord::Base
+      has_many :images
+      has_and_belongs_to_many :sections
+
+      amoeba do
+        include_field :images
+        propagate
+      end
+    end
+
+    class Shirt < Product
+      include_field [:sections]
+    end
+
+#### A Relaxed Override Example
+
+This version will use both the parent and child settings, so both the images and sections will be copied.
+
+    class Product < ActiveRecord::Base
+      has_many :images
+      has_and_belongs_to_many :sections
+
+      amoeba do
+        include_field :images
+        propagate :relaxed
+      end
+    end
+
+    class Shirt < Product
+      include_field :sections
+    end
+
+The next version will use only the parent settings because passing an array will override any previous settings rather than adding to them and the parent config takes precedence in the `relaxed` parenting style. So in this case only the images will be copied.
+
+    class Product < ActiveRecord::Base
+      has_many :images
+      has_and_belongs_to_many :sections
+
+      amoeba do
+        include_field [:images]
+        propagate
+      end
+    end
+
+    class Shirt < Product
+      include_field :sections
+    end
+
 ### Limiting Association Types
 
 By default, amoeba recognizes and attemps to copy any children of the following association types:
@@ -552,55 +739,83 @@ You may control how amoeba copies your object, on the fly, by passing a configur
       end
     end
 
-### Config-Block Reference
+### Configuration Reference
 
 Here is a static reference to the available configuration methods, usable within the amoeba block on your rails models.
 
 #### Controlling Associations
 
-`enable`
+* `enable`
+
+  Enables amoeba in the default style of copying all known associated child records. Using the enable method is only required if you wish to enable amoeba but you are not using either the `include_field` or `exclude_field` directives. If you use either inclusive or exclusive style, amoeba is automatically enabled for you, so calling `enable` would be redundant, though it won't hurt.
+
+* `include_field`
+
+  Adds a field to the list of fields which should be copied. All associations not in this list will not be copied. This method may be called multiple times, once per desired field, or you may pass an array of field names. Passing a single symbol will add to the list of included fields. Passing an array will empty the list and replace it with the array you pass.
 
-Enables amoeba in the default style of copying all known associated child records. Using the enable method is only required if you wish to enable amoeba but you are not using either the `include_field` or `exclude_field` directives. If you use either inclusive or exclusive style, amoeba is automatically enabled for you, so calling `enable` would be redundant, though it won't hurt.
+* `exclude_field`
 
-`include_field`
+  Adds a field to the list of fields which should not be copied. Only the associations that are not in this list will be copied. This method may be called multiple times, once per desired field, or you may pass an array of field names. Passing a single symbol will add to the list of excluded fields. Passing an array will empty the list and replace it with the array you pass.
 
-Adds a field to the list of fields which should be copied. All associations not in this list will not be copied. This method may be called multiple times, once per desired field, or you may pass an array of field names. Passing a single symbol will add to the list of included fields. Passing an array will empty the list and replace it with the array you pass.
+* `clone`
 
-`exclude_field`
+  Adds a field to the list of associations which should have their associated children actually cloned. This means for example, that instead of just maintaining original associations with previously existing tags, a copy will be made of each tag, and the new record will be associated with these new tag copies rather than the old tag copies. This method may be called multiple times, once per desired field, or you may pass an array of field names. Passing a single symbol will add to the list of excluded fields. Passing an array will empty the list and replace it with the array you pass.
 
-Adds a field to the list of fields which should not be copied. Only the associations that are not in this list will be copied. This method may be called multiple times, once per desired field, or you may pass an array of field names. Passing a single symbol will add to the list of excluded fields. Passing an array will empty the list and replace it with the array you pass.
+* `propagate`
 
-`clone`
+  This causes any inherited child models to take the same config settings when copied. This method may take up to one argument to control the so called "parenting style". The argument should be one of `strict`, `relaxed` or `submissive`.
+
+  The default "parenting style" is `submissive`
+
+  for example
+
+        amoeba do
+          propagate :strict
+        end
+
+  will choose the strict parenting style of inherited settings.
+
+* `raised`
+
+  This causes any child to behave with a (potentially) different "parenting style" than its actual parent. This method takes up to a single parameter for which there are three options, `strict`, `relaxed` and `submissive`.
+
+  The default "parenting style" is `submissive`
+
+  for example:
+
+        amoeba do
+          raised :relaxed
+        end
 
-Adds a field to the list of associations which should have their associated children actually cloned. This means for example, that instead of just maintaining original associations with previously existing tags, a copy will be made of each tag, and the new record will be associated with these new tag copies rather than the old tag copies. This method may be called multiple times, once per desired field, or you may pass an array of field names. Passing a single symbol will add to the list of excluded fields. Passing an array will empty the list and replace it with the array you pass.
+  will choose the relaxed parenting style of inherited settings for this child. A parenting style set via the `raised` method takes precedence over the parenting style set using the `propagate` method.
 
 #### Pre-Processing Fields
 
-`nullify`
+* `nullify`
 
-Adds a field to the list of non-association based fields which should be set to nil during copy. All fields in this list will be set to `nil` - note that any nullified field will be given its default value if a default value exists on this model's migration. This method may be called multiple times, once per desired field, or you may pass an array of field names. Passing a single symbol will add to the list of null fields. Passing an array will empty the list and replace it with the array you pass.
+  Adds a field to the list of non-association based fields which should be set to nil during copy. All fields in this list will be set to `nil` - note that any nullified field will be given its default value if a default value exists on this model's migration. This method may be called multiple times, once per desired field, or you may pass an array of field names. Passing a single symbol will add to the list of null fields. Passing an array will empty the list and replace it with the array you pass.
 
-`prepend`
+* `prepend`
 
-Prefix a field with some text. This only works for string fields. Accepts a hash of fields to prepend. The keys are the field names and the values are the prefix strings. An example scenario would be to add a string such as "Copy of " to your title field. Don't forget to include extra space to the right if you want it. Passing a hash will add each key value pair to the list of prepend directives. If you wish to empty the list of directives, you may pass the hash inside of an array like this `[{:title => "Copy of "}]`.
+  Prefix a field with some text. This only works for string fields. Accepts a hash of fields to prepend. The keys are the field names and the values are the prefix strings. An example scenario would be to add a string such as "Copy of " to your title field. Don't forget to include extra space to the right if you want it. Passing a hash will add each key value pair to the list of prepend directives. If you wish to empty the list of directives, you may pass the hash inside of an array like this `[{:title => "Copy of "}]`.
 
-`append`
+* `append`
 
-Append some text to a field. This only works for string fields. Accepts a hash of fields to prepend. The keys are the field names and the values are the prefix strings. An example would be to add " (copied version)" to your description field. Don't forget to add a leading space if you want it. Passing a hash will add each key value pair to the list of append directives. If you wish to empty the list of directives, you may pass the hash inside of an array like this `[{:contents => " (copied version)"}]`.
+  Append some text to a field. This only works for string fields. Accepts a hash of fields to prepend. The keys are the field names and the values are the prefix strings. An example would be to add " (copied version)" to your description field. Don't forget to add a leading space if you want it. Passing a hash will add each key value pair to the list of append directives. If you wish to empty the list of directives, you may pass the hash inside of an array like this `[{:contents => " (copied version)"}]`.
 
-`set`
+* `set`
 
-Set a field to a given value. This sould work for almost any type of field. Accepts a hash of fields and the values you want them set to.. The keys are the field names and the values are the prefix strings. An example would be to add " (copied version)" to your description field. Don't forget to add a leading space if you want it. Passing a hash will add each key value pair to the list of append directives. If you wish to empty the list of directives, you may pass the hash inside of an array like this `[{:approval_state => "open_for_editing"}]`.
+  Set a field to a given value. This sould work for almost any type of field. Accepts a hash of fields and the values you want them set to.. The keys are the field names and the values are the prefix strings. An example would be to add " (copied version)" to your description field. Don't forget to add a leading space if you want it. Passing a hash will add each key value pair to the list of append directives. If you wish to empty the list of directives, you may pass the hash inside of an array like this `[{:approval_state => "open_for_editing"}]`.
 
-`regex`
+* `regex`
 
-Globally search and replace the field for a given pattern. Accepts a hash of fields to run search and replace upon. The keys are the field names and the values are each a hash with information about what to find and what to replace it with. in the form of . An example would be to replace all occurrences of the word "dog" with the word "cat", the parameter hash would look like this `:contents => {:replace => /dog/, :with => "cat"}`. Passing a hash will add each key value pair to the list of regex directives. If you wish to empty the list of directives, you may pass the hash inside of an array like this `[{:contents => {:replace => /dog/, :with => "cat"}]`.
+  Globally search and replace the field for a given pattern. Accepts a hash of fields to run search and replace upon. The keys are the field names and the values are each a hash with information about what to find and what to replace it with. in the form of . An example would be to replace all occurrences of the word "dog" with the word "cat", the parameter hash would look like this `:contents => {:replace => /dog/, :with => "cat"}`. Passing a hash will add each key value pair to the list of regex directives. If you wish to empty the list of directives, you may pass the hash inside of an array like this `[{:contents => {:replace => /dog/, :with => "cat"}]`.
 
-`customize`
+* `customize`
 
-Runs a custom method so you can do basically whatever you want. All you need to do is pass a lambda block or an array of lambda blocks that take two parameters, the original object and the new object copy
+  Runs a custom method so you can do basically whatever you want. All you need to do is pass a lambda block or an array of lambda blocks that take two parameters, the original object and the new object copy
 
-This method may be called multiple times, once per desired customizer block, or you may pass an array of lambdas. Passing a single lambda will add to the list of processing directives. Passing an array will empty the list and replace it with the array you pass.
+  This method may be called multiple times, once per desired customizer block, or you may pass an array of lambdas. Passing a single lambda will add to the list of processing directives. Passing an array will empty the list and replace it with the array you pass.
 
 ## Known Limitations and Issues
 

data/lib/amoeba.rb

@@ -2,25 +2,38 @@ require "active_record"
 require "amoeba/version"
 
 module Amoeba
-  module ClassMethods
-    def amoeba(&block)
-      @config ||= Amoeba::ClassMethods::Config.new
-      @config.instance_eval(&block) if block_given?
-      @config
-    end
-
+  module Dsl # {{{
     class Config
+      def initialize(parent)
+        @parent = parent
+      end
+
       # Getters {{{
+      def upbringing
+        @raised ||= false
+        @raised
+      end
+
       def enabled
         @enabled ||= false
         @enabled
       end
 
+      def inherit
+        @inherit ||= false
+        @inherit
+      end
+
       def do_preproc
         @do_preproc ||= false
         @do_preproc
       end
 
+      def parenting
+        @parenting ||= false
+        @parenting
+      end
+
       def known_macros
         @known_macros ||= [:has_one, :has_many, :has_and_belongs_to_many]
         @known_macros
@@ -81,8 +94,18 @@ module Amoeba
         @enabled = false
       end
 
+      def raised(style=:submissive)
+        @raised = style
+      end
+
+      def propagate(style=:submissive)
+        @parenting ||= style
+        @inherit = true
+      end
+
       def include_field(value=nil)
         @enabled ||= true
+        @excludes = []
         @includes ||= []
         if value.is_a?(Array)
           @includes = value
@@ -94,6 +117,7 @@ module Amoeba
 
       def exclude_field(value=nil)
         @enabled ||= true
+        @includes = []
         @excludes ||= []
         if value.is_a?(Array)
           @excludes = value
@@ -224,13 +248,141 @@ module Amoeba
       end
       # }}}
     end
+  end # }}}
+
+  module ClassMethods
+    def amoeba(&block)
+      @config_block ||= block if block_given?
+
+      @config ||= Amoeba::Dsl::Config.new(self)
+      @config.instance_eval(&block) if block_given?
+      @config
+    end
+
+    def fresh_amoeba(&block)
+      @config_block = block if block_given?
+
+      @config = Amoeba::Dsl::Config.new(self)
+      @config.instance_eval(&block) if block_given?
+      @config
+    end
+
+    def amoeba_block
+      @config_block
+    end
   end
 
   module InstanceMethods
+    # Config Getters {{{
     def amoeba_conf
       self.class.amoeba
     end
 
+    def has_parent_amoeba_conf?
+      self.class.superclass.respond_to?(:amoeba)
+    end
+
+    def parent_amoeba_conf
+      if has_parent_amoeba_conf?
+        self.class.superclass.amoeba
+      else
+        false
+      end
+    end
+
+    def amoeba_settings
+      self.class.amoeba_block
+    end
+
+    def has_parent_amoeba_settings?
+      self.class.superclass.respond_to?(:amoeba_block)
+    end
+
+    def parent_amoeba_settings
+      if has_parent_amoeba_conf?
+        self.class.superclass.amoeba_block
+      else
+        false
+      end
+    end
+    # }}}
+
+    def dup(options={})
+      @result = super()
+
+      if !amoeba_conf.enabled && parent_amoeba_conf.inherit
+        if amoeba_conf.upbringing
+          parenting_style = amoeba_conf.upbringing
+        else
+          parenting_style = parent_amoeba_conf.parenting
+        end
+
+        case parenting_style
+        when :strict
+          # parent settings only
+          self.class.fresh_amoeba(&parent_amoeba_settings)
+        when :relaxed
+          # parent takes precedence
+          self.class.amoeba(&parent_amoeba_settings)
+        when :submissive
+          # parent suggests things
+          # child does what it wants to anyway
+          child_settings = amoeba_settings
+          self.class.fresh_amoeba(&parent_amoeba_settings)
+          self.class.amoeba(&child_settings)
+        end
+      end
+
+      # Run Amoeba {{{
+      if amoeba_conf.enabled
+        # Deep Clone Settings {{{
+        amoeba_conf.clones.each do |clone_field|
+          r = self.class.reflect_on_association clone_field
+
+          # if this is a has many through and we're gonna deep
+          # copy the  child records, exclude the  regular join
+          # table from copying so we don't end up with the new
+          # and old children on the copy
+          if r.macro == :has_many && r.is_a?(ActiveRecord::Reflection::ThroughReflection)
+            amoeba_conf.exclude_field r.options[:through]
+          end
+        end
+        # }}}
+
+        # Inclusive Style {{{
+        if amoeba_conf.includes.count > 0
+          amoeba_conf.includes.each do |i|
+            r = self.class.reflect_on_association i
+            amo_process_association(i, r)
+          end
+        # }}}
+        # Exclusive Style {{{
+        elsif amoeba_conf.excludes.count > 0
+          reflections.each do |r|
+            if not amoeba_conf.excludes.include?(r[0])
+              amo_process_association(r[0], r[1])
+            end
+          end
+        # }}}
+        # Indiscriminate Style {{{
+        else
+          reflections.each do |r|
+            amo_process_association(r[0], r[1])
+          end
+        end
+        # }}}
+      end
+
+      if amoeba_conf.do_preproc
+        amo_preprocess_parent_copy
+      end
+      # }}}
+
+      @result
+    end
+
+  private
+    # Copy Children {{{
     def amo_process_association(relation_name, settings)
       if not amoeba_conf.known_macros.include?(settings.macro)
         return
@@ -303,49 +455,10 @@ module Amoeba
         end
       end
     end
+    # }}}
 
-    def dup(options={})
-      @result = super()
-
-      amoeba_conf.clones.each do |clone_field|
-        r = self.class.reflect_on_association clone_field
-
-        # if this is a has many through and we're gonna deep
-        # copy the  child records, exclude the  regular join
-        # table from copying so we don't end up with the new
-        # and old children on the copy
-        if r.macro == :has_many && r.is_a?(ActiveRecord::Reflection::ThroughReflection)
-          amoeba_conf.exclude_field r.options[:through]
-        end
-      end
-
-      if amoeba_conf.enabled
-        if amoeba_conf.includes.count > 0
-          amoeba_conf.includes.each do |i|
-            r = self.class.reflect_on_association i
-            amo_process_association(i, r)
-          end
-        elsif amoeba_conf.excludes.count > 0
-          reflections.each do |r|
-            if not amoeba_conf.excludes.include?(r[0])
-              amo_process_association(r[0], r[1])
-            end
-          end
-        else
-          reflections.each do |r|
-            amo_process_association(r[0], r[1])
-          end
-        end
-      end
-
-      if amoeba_conf.do_preproc
-        preprocess_parent_copy
-      end
-
-      @result
-    end
-
-    def preprocess_parent_copy
+    # Field Preprocessor {{{
+    def amo_preprocess_parent_copy
       # nullify any fields the user has configured
       amoeba_conf.null_fields.each do |n|
         @result[n] = nil
@@ -376,6 +489,7 @@ module Amoeba
         @result[field].gsub!(action[:replace], action[:with])
       end
     end
+    # }}}
   end
 end
 

data/lib/amoeba/version.rb

@@ -1,3 +1,3 @@
 module Amoeba
-  VERSION = "1.1.0"
+  VERSION = "1.2.0"
 end

data/spec/lib/amoeba_spec.rb

@@ -4,6 +4,7 @@ require 'spec_helper'
 describe "amoeba" do
   context "dup" do
     it "duplicates associated child records" do
+      # Posts {{{
       old_post = Post.find(1)
       old_post.comments.map(&:contents).include?("I love it!").should be true
 
@@ -81,6 +82,88 @@ describe "amoeba" do
       new_post.widgets.map(&:id).each do |id|
         old_post.widgets.map(&:id).include?(id).should_not be true
       end
+      # }}}
+      # Products {{{
+      # Base Class {{{
+      old_product = Product.find(1)
+
+      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"]
+
+      new_product = old_product.dup
+      new_product.save
+
+      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.should == start_image_count
+      end_newimage_count.should == start_image_count
+      end_section_count.should == start_section_count
+      end_prodsection_count.should == start_prodsection_count
+      end_newprodsection_count.should == start_prodsection_count
+      # }}}
+
+      # Inherited Class {{{
+      # 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"]
+
+      new_product = old_product.dup
+      new_product.save
+
+      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.should == start_image_count
+      end_newimage_count.should == start_image_count
+      end_section_count.should == start_section_count
+      end_prodsection_count.should == start_prodsection_count
+      end_newprodsection_count.should == start_prodsection_count
+      # }}}
+
+      # 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"]
+
+      new_product = old_product.dup
+      new_product.save
+
+      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.should == start_image_count
+      end_newimage_count.should == start_image_count
+      end_section_count.should == start_section_count
+      end_prodsection_count.should == start_prodsection_count
+      end_newprodsection_count.should == start_prodsection_count
+      # }}}
+      # }}}
+      # }}}
     end
   end
 end

data/spec/support/data.rb

@@ -79,3 +79,37 @@ s3.superkittens.create(:value => "Dopey")
 s3.superkittens.create(:value => "Sneezy")
 s3.superkittens.create(:value => "Sleepy")
 # }}}
+
+# Product {{{
+product1 = Product.create(:title => "Sticky Notes 5-Pak", :price => 5.99, :weight => 0.56)
+shirt1 = Shirt.create(:title => "Fancy Shirt", :price => 48.95, :sleeve => 32, :collar => 15.5)
+necklace1 = Necklace.create(:title => "Pearl Necklace", :price => 2995.99, :length => 18, :metal => "14k")
+
+img1 = product1.images.create(:filename => "sticky.jpg")
+img2 = product1.images.create(:filename => "notes.jpg")
+
+img1 = shirt1.images.create(:filename => "02948u31.jpg")
+img2 = shirt1.images.create(:filename => "zsif8327.jpg")
+
+img1 = necklace1.images.create(:filename => "ae02x9f1.jpg")
+img2 = necklace1.images.create(:filename => "cba9f912.jpg")
+
+office = Section.create(:name => "Office", :num_employees => 2, :total_sales => "1234.56")
+supplies = Section.create(:name => "Supplies", :num_employees => 1, :total_sales => "543.21")
+mens = Section.create(:name => "Mens", :num_employees => 3, :total_sales => "11982.63")
+apparel = Section.create(:name => "Apparel", :num_employees => 5, :total_sales => "1315.20")
+accessories = Section.create(:name => "Accessories", :num_employees => 1, :total_sales => "8992.34")
+jewelry = Section.create(:name => "Jewelry", :num_employees => 3, :total_sales => "25481.77")
+
+product1.sections << office
+product1.sections << supplies
+product1.save
+
+shirt1.sections << mens
+shirt1.sections << apparel
+shirt1.save
+
+necklace1.sections << jewelry
+necklace1.sections << accessories
+necklace1.save
+# }}}

data/spec/support/models.rb

@@ -144,3 +144,46 @@ end
 class User < ActiveRecord::Base
   has_many :posts
 end
+
+# Inheritance
+class Product < ActiveRecord::Base
+  has_many :images
+  has_and_belongs_to_many :sections
+
+  amoeba do
+    enable
+    propagate
+  end
+end
+
+class Section < ActiveRecord::Base
+end
+
+class Image < ActiveRecord::Base
+end
+
+class Shirt < Product
+  amoeba do
+    raised :submissive
+  end
+end
+
+class Necklace < Product
+  amoeba do
+    raised :relaxed
+  end
+end
+
+# Polymorphism
+class Address < ActiveRecord::Base
+  belongs_to :addressable, :polymorphic => true
+end
+
+class Employee < ActiveRecord::Base
+  has_many :addresses, :as => :addressable
+end
+
+class Customer < ActiveRecord::Base
+  has_many :addresses, :as => :addressable
+end
+

data/spec/support/schema.rb

@@ -15,6 +15,57 @@ ActiveRecord::Schema.define do
     t.timestamps
   end
 
+  create_table :products, :force => true do |t|
+    t.string :type
+    t.string :title
+    t.decimal :price
+    t.decimal :weight
+    t.decimal :cost
+    t.decimal :sleeve
+    t.decimal :collar
+    t.decimal :length
+    t.string :metal
+  end
+
+  create_table :products_sections, :force => true do |t|
+    t.integer :section_id
+    t.integer :product_id
+  end
+
+  create_table :sections, :force => true do |t|
+    t.string :name
+    t.integer :num_employees
+    t.decimal :total_sales
+  end
+
+  create_table :images, :force => true do |t|
+    t.string :filename
+    t.integer :product_id
+  end
+
+  create_table :employees, :force => true do |t|
+    t.string :name
+    t.string :ssn
+    t.decimal :salary
+  end
+
+  create_table :customers, :force => true do |t|
+    t.string :email
+    t.string :password
+    t.decimal :balance
+  end
+
+  create_table :addresses, :force => true do |t|
+    t.integer :addressable_id
+    t.string :addressable_type
+
+    t.string :street
+    t.string :unit
+    t.string :city
+    t.string :state
+    t.string :zip
+  end
+
   create_table :post_configs, :force => true do |t|
     t.integer :post_id
     t.integer :is_visible

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: amoeba
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-03-22 00:00:00.000000000 Z
+date: 2012-03-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &8806100 !ruby/object:Gem::Requirement
+  requirement: &11153980 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *8806100
+  version_requirements: *11153980
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &8805580 !ruby/object:Gem::Requirement
+  requirement: &11153480 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '2.3'
   type: :development
   prerelease: false
-  version_requirements: *8805580
+  version_requirements: *11153480
 - !ruby/object:Gem::Dependency
   name: sqlite3-ruby
-  requirement: &8805180 !ruby/object:Gem::Requirement
+  requirement: &11153080 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *8805180
+  version_requirements: *11153080
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &8804640 !ruby/object:Gem::Requirement
+  requirement: &11152540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,7 +54,7 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *8804640
+  version_requirements: *11152540
 description: ! 'An extension to ActiveRecord to allow the duplication method to also
   copy associated children, with recursive support for nested of grandchildren. The
   behavior is controllable with a simple DSL both on your rails models and on the