amoeba 0.0.2 → 0.1.0

data/.gitignore

@@ -2,3 +2,4 @@
 .bundle
 Gemfile.lock
 pkg/*
+spec/test.sqlite3

data/README.md

@@ -1,24 +1,37 @@
 # Amoeba
 
-## Overview
-
 Easy copying of rails associations such as `has_many`.
 
-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.
+![amoebalogo](http://rocksolidwebdesign.com/wp_cms/wp-content/uploads/2012/02/amoeba_logo.jpg)
+
+## Background
+
+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.
 
 ## Details
 
 An ActiveRecord extension gem to allow the duplication of associated child record objects when duplicating an active record model. This gem overrides and adds to the built in `ActiveRecord::Base#dup` method.
 
-Rails 3 compatible.
+Rails 3.2 compatible.
 
 ## Features
 
- - Supports automatic recursive duplication of associated `has_one`, `has_many` and `has_and_belongs_to_many` child records.
- - Allows configuration of which fields to copy through a simple DSL applied to your rails models.
- - Supports multiple configuration styles such as inclusive, exclusive and indiscriminate (aka copy everything).
- - Supports preprocessing of fields to help indicate uniqueness and ensure the integrity of your data depending on your business logic needs.
- - Supports per instance configuration to override configuration and behavior on the fly.
+- Supports the following association types
+    - `has_many`
+    - `has_one :through`
+    - `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.
+- Multiple configuration styles such as inclusive, exclusive and indiscriminate (aka copy everything).
+- Supports 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.
+- Amoeba can perform the following preprocessing operations on fields of copied records
+    - prepend
+    - append
+    - nullify
+    - regex
 
 ## Installation
 
@@ -67,7 +80,7 @@ If you have some models for a blog about like this:
       belongs_to :post
     end
 
-Add the amoeba configuration block to your model and call the enable method to enable the copying of child records, like this:
+simply add the amoeba configuration block to your model and call the enable method to enable the copying of child records, like this:
 
     class Post < ActiveRecord::Base
       has_many :comments
@@ -360,6 +373,62 @@ You may cause amoeba to keep copying down the chain as far as you like, simply a
 
 In this example, when a post is copied, amoeba will copy each all of a post's comments and will also copy each comment's ratings.
 
+### Has One Through
+
+Using the `has_one :through` association is simple, just be sure to enable amoeba on the each model with a `has_one` association and amoeba will automatically and recursively drill down, like so:
+
+    class Supplier < ActiveRecord::Base
+      has_one :account
+      has_one :history, :through => :account
+
+      amoeba do
+        enable
+      end
+    end
+
+    class Account < ActiveRecord::Base
+      belongs_to :supplier
+      has_one :history
+
+      amoeba do
+        enable
+      end
+    end
+
+    class History < ActiveRecord::Base
+      belongs_to :account
+    end
+
+### Has Many Through
+
+Copying `has_many :through` associations work automatically. They perform the copy in the same way as the `has_and_belongs_to_many` association, meaning the actual child records are not copied, but rather the associations are simply maintained. You can add some field preprocessors to the middle model if you like but this is not strictly necessary:
+
+    class Assembly < ActiveRecord::Base
+      has_many :manifests
+      has_many :parts, :through => :manifests
+
+      amoeba do
+        enable
+      end
+    end
+
+    class Manifest < ActiveRecord::Base
+      belongs_to :assembly
+      belongs_to :part
+
+      amoeba do
+        prefix :notes => "Copy of "
+      end
+    end
+
+    class Part < ActiveRecord::Base
+      has_many :manifests
+      has_many :assemblies, :through => :manifests
+
+      amoeba do
+        enable
+      end
+    end
 
 ### On The Fly Configuration
 
@@ -403,35 +472,35 @@ Here is a static reference to the available configuration methods, usable within
 
 `enable`
 
-Enables amoeba in the default style of copying all known associated child records.
+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.
+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.
 
 `exclude_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.
+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.
 
 `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.
+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`
 
-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.
+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 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.
+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 prepend directives. If you wish to empty the list of directives, you may pass the hash inside of an array like this `[{:contents => " (copied version)"}]`.
 
 `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"}`
+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 prepend 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"}]`.
 
 ## Known Limitations and Issues
 
-Amoeba does not yet recognize advanced versions of `has_and_belongs_to_many` such as `has_and_belongs_to_many :foo, :through => :bar`. Amoeba does not copy the actual HABMT child records but rather simply adds records to the M:M breakout table to associate the new parent copy with the same records that the original parent were associated with. In other words, it doesn't duplicate your tags or categories, but merely reassociates your parent copy with the same tags or categories that the old parent had.
+Amoeba does not copy the actual HABMT child records but rather simply adds records to the M:M breakout table to associate the new parent copy with the same records that the original parent were associated with. In other words, it doesn't duplicate your tags or categories, but merely reassociates your parent copy with the same tags or categories that the old parent had.
 
 The regular expression preprocessor uses case-sensitive `String#gsub`. Given the performance decreases inherrent in using regular expressions already, the fact that character classes can essentially account for case-insensitive searches, the desire to keep the DSL simple and the general use cases for this gem, I don't see a good reason to add yet more decision based conditional syntax to accommodate using case-insensitive searches or singular replacements with `String#sub`. If you find yourself wanting either of these features, by all means fork the code base and if you like your changes, submit a pull request.
 
@@ -446,3 +515,17 @@ You may run the rspec tests like this:
 ## TODO
 
 Write more tests.... anyone?
+
+## License
+
+[The BSD License](http://www.opensource.org/licenses/bsd-license.php)
+
+Copyright (c) 2012, Vaughn Draughon
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+ - Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+ - Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

data/amoeba.gemspec

@@ -10,7 +10,14 @@ Gem::Specification.new do |s|
   s.homepage    = "http://github.com/rocksolidwebdesign/amoeba"
   s.license     = "BSD"
   s.summary     = %q{Easy copying of rails models and their child associations.}
-  s.description = %q{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 fly, i.e. per instance. Numerous configuration options and styles and preprocessing directives are included for power and flexibility. Tags: copy child associations, copy nested children, copy associated child records, deep_copy, nested copy, copy associations, copy relations, copy relationships, has_one, has_many, has_and_belongs_to_many, duplicate associations, duplicate associated records, duplicate child records, duplicate children, copy all, duplicate all.}
+
+  s.description = <<-EOF
+    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 fly, i.e. per instance. Numerous configuration options and styles and preprocessing directives are included for power and flexibility. Supports preprocessing of field values to prepend strings such as "Copy of " or to nullify field values - includes a regex preprocessor. Supports most association types including has_one :through and has_many :through.
+
+    Tags: copy child associations, copy nested children, copy associated child records, nested copy, copy associations, copy relations, copy relationships, duplicate associations, duplicate associated records, duplicate child records, duplicate children, copy all, duplicate all, clone child associations, clone nested children, clone associated child records, nested clone, clone associations, clone relations, clone relationships, cloning child associations, cloning nested children, cloning associated child records, deep_cloning, nested cloning, cloning associations, cloning relations, cloning relationships, cloning child associations, cloning nested children, cloning associated child records, nested cloning, cloning associations, cloning relations, cloning relationships, cloning child associations, cloning nested children, cloning associated child records, deep_cloning, nested cloning, cloning associations, cloning relations, cloning relationships, duplicate child associations, duplicate nested children, duplicate associated child records, nested duplicate, duplicate associations, duplicate relations, duplicate relationships, duplicate child associations, duplicate nested children, duplicate associated child records, deep_duplicate, nested duplicate, duplicate associations, duplicate relations, duplicate relationships, deep_copy, deep_clone, deep_cloning, deep clone, deep cloning, has_one, has_many, has_and_belongs_to_many
+  EOF
+
+  s.description = %q{}
 
   s.rubyforge_project = "amoeba"
 

data/lib/amoeba.rb

@@ -181,13 +181,27 @@ module Amoeba
 
       case settings.macro
       when :has_one
+        if settings.is_a?(ActiveRecord::Reflection::ThroughReflection)
+          return
+        end
+
         old_obj = self.send(relation_name)
 
-        copy_of_obj = old_obj.dup
-        copy_of_obj[:"#{settings.foreign_key}"] = nil
+        if not old_obj.nil?
+          copy_of_obj = old_obj.dup
+          copy_of_obj[:"#{settings.foreign_key}"] = nil
 
-        @result.send(:"#{relation_name}=", copy_of_obj)
+          @result.send(:"#{relation_name}=", copy_of_obj)
+        end
       when :has_many
+        # copying the children of the regular has many will
+        # effectively do what is desired anyway, the through
+        # association is really just for convenience usage
+        # on the model
+        if settings.is_a?(ActiveRecord::Reflection::ThroughReflection)
+          return
+        end
+
         self.send(relation_name).each do |old_obj|
           copy_of_obj = old_obj.dup
           copy_of_obj[:"#{settings.foreign_key}"] = nil

data/lib/amoeba/version.rb

@@ -1,3 +1,3 @@
 module Amoeba
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/spec/lib/amoeba_spec.rb

@@ -13,6 +13,10 @@ describe "amoeba" do
 
       new_post = old_post.dup
 
+      start_account_count = Account.all.count
+      start_history_count = History.all.count
+      start_cat_count = Category.all.count
+      start_supercat_count = Supercat.all.count
       start_tag_count = Tag.all.count
       start_post_count = Post.all.count
       start_comment_count = Comment.all.count
@@ -23,6 +27,10 @@ describe "amoeba" do
 
       new_post.save
 
+      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_tag_count = Tag.all.count
       end_post_count = Post.all.count
       end_comment_count = Comment.all.count
@@ -32,12 +40,17 @@ describe "amoeba" do
       end_posttag_count = rs["tag_count"]
 
       end_tag_count.should         == start_tag_count
+      end_cat_count.should         == start_cat_count
+      end_account_count.should     == start_account_count * 2
+      end_history_count.should     == start_history_count * 2
+      end_supercat_count.should    == start_supercat_count * 2
       end_post_count.should        == start_post_count * 2
       end_comment_count.should     == start_comment_count * 2
       end_rating_count.should      == start_rating_count * 2
       end_postconfig_count.should  == start_postconfig_count * 2
       end_posttag_count.should     == start_posttag_count * 2
 
+      new_post.supercats.map(&:ramblings).include?("Copy of zomg").should be true
       new_post.title.should == "Copy of #{old_post.title}"
       new_post.contents.should == "Here's a copy: #{old_post.contents.gsub(/dog/, 'cat')} (copied version)"
     end

data/spec/support/data.rb

@@ -6,6 +6,8 @@ t = Topic.create(:title => "Ponies", :description => "Lets talk about my ponies.
 # First Post {{{
 p1 = t.posts.create(:author => u1, :title => "My little pony", :contents => "Lorum ipsum dolor rainbow bright. I like dogs, dogs are awesome.")
 f1 = p1.create_post_config(:is_visible => true, :is_open => false, :password => 'abcdefg123')
+a1 = p1.create_account(:title => "Foo")
+h1 = p1.account.create_history(:some_stuff => "Bar")
 c1 = p1.comments.create(:contents => "I love it!")
 c1.ratings.create(:num_stars => 5)
 c1.ratings.create(:num_stars => 5)
@@ -22,7 +24,7 @@ c2.ratings.create(:num_stars => 1)
 c2.ratings.create(:num_stars => 1)
 c2.ratings.create(:num_stars => 2)
 
-c3 = p1.comments.create(:contents => "zomg kthxbbq!!11!!!1!eleven!!")
+c3 = p1.comments.create(:contents => "kthxbbq!!11!!!1!eleven!!")
 c3.ratings.create(:num_stars => 0)
 c3.ratings.create(:num_stars => 0)
 c3.ratings.create(:num_stars => 1)
@@ -38,4 +40,12 @@ p1.tags << t1
 p1.tags << t2
 p1.tags << t3
 p1.save
+
+c1 = Category.create(:title => "Umbrellas", :description => "Clown fart")
+c2 = Category.create(:title => "Widgets", :description => "Humpty dumpty")
+c3 = Category.create(:title => "Wombats", :description => "Slushy mushy")
+
+Supercat.create(:post => p1, :category => c1, :ramblings => "zomg")
+Supercat.create(:post => p1, :category => c2, :ramblings => "why")
+Supercat.create(:post => p1, :category => c3, :ramblings => "ohnoes")
 # }}}

data/spec/support/models.rb

@@ -6,7 +6,11 @@ class Post < ActiveRecord::Base
   belongs_to :topic
   belongs_to :author, :class_name => 'User'
   has_one :post_config
+  has_one :account
+  has_one :history, :through => :account
   has_many :comments
+  has_many :supercats
+  has_many :categories, :through => :supercats
   has_and_belongs_to_many :tags
 
   amoeba do
@@ -17,6 +21,33 @@ class Post < ActiveRecord::Base
   end
 end
 
+class Account < ActiveRecord::Base
+  belongs_to :post
+  has_one :history
+
+  amoeba do
+    enable
+  end
+end
+
+class History < ActiveRecord::Base
+  belongs_to :account
+end
+
+class Category < ActiveRecord::Base
+  has_many :supercats
+  has_many :posts, :through => :supercats
+end
+
+class Supercat < ActiveRecord::Base
+  belongs_to :post
+  belongs_to :category
+
+  amoeba do
+    prepend :ramblings => "Copy of "
+  end
+end
+
 class PostConfig < ActiveRecord::Base
   belongs_to :post
 end

data/spec/support/schema.rb

@@ -58,4 +58,28 @@ ActiveRecord::Schema.define do
     t.integer :post_id
     t.integer :tag_id
   end
+
+  create_table :categories, :force => true do |t|
+    t.string :title
+    t.string :description
+  end
+
+  create_table :supercats, :force => true do |t|
+    t.integer :post_id
+    t.integer :category_id
+    t.string :ramblings
+    t.timestamps
+  end
+
+  create_table :accounts, :force => true do |t|
+    t.integer :post_id
+    t.string :title
+    t.timestamps
+  end
+
+  create_table :histories, :force => true do |t|
+    t.integer :account_id
+    t.string :some_stuff
+    t.timestamps
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: amoeba
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2012-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &14811680 !ruby/object:Gem::Requirement
+  requirement: &15890320 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: 1.0.0
   type: :development
   prerelease: false
-  version_requirements: *14811680
+  version_requirements: *15890320
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &14811140 !ruby/object:Gem::Requirement
+  requirement: &15889800 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '2.3'
   type: :development
   prerelease: false
-  version_requirements: *14811140
+  version_requirements: *15889800
 - !ruby/object:Gem::Dependency
   name: sqlite3-ruby
-  requirement: &14810740 !ruby/object:Gem::Requirement
+  requirement: &15889380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,10 +43,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *14810740
+  version_requirements: *15889380
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &14810080 !ruby/object:Gem::Requirement
+  requirement: &15888640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -54,16 +54,8 @@ dependencies:
         version: '3.0'
   type: :runtime
   prerelease: false
-  version_requirements: *14810080
-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
-  fly, i.e. per instance. Numerous configuration options and styles and preprocessing
-  directives are included for power and flexibility. Tags: copy child associations,
-  copy nested children, copy associated child records, deep_copy, nested copy, copy
-  associations, copy relations, copy relationships, has_one, has_many, has_and_belongs_to_many,
-  duplicate associations, duplicate associated records, duplicate child records, duplicate
-  children, copy all, duplicate all.'
+  version_requirements: *15888640
+description: ''
 email: vaughn@rocksolidwebdesign.com
 executables: []
 extensions: []
@@ -77,12 +69,12 @@ files:
 - amoeba.gemspec
 - lib/amoeba.rb
 - lib/amoeba/version.rb
+- logo.jpg
 - spec/lib/amoeba_spec.rb
 - spec/spec_helper.rb
 - spec/support/data.rb
 - spec/support/models.rb
 - spec/support/schema.rb
-- spec/test.sqlite3
 homepage: http://github.com/rocksolidwebdesign/amoeba
 licenses:
 - BSD