amoeba 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rvmrc

@@ -0,0 +1 @@
+rvm use --create 1.9.3-p0@amoeba

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in power_dup.gemspec
+gemspec

data/README.md

@@ -0,0 +1,448 @@
+# 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.
+
+## 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.
+
+## 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.
+
+## 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:
+
+    p = Post.create(:title => "Hello World!", :content => "Lorum ipsum dolor")
+    p.comments.create(:content => "I love it!")
+    p.comments.create(:content => "This sucks!")
+
+    puts Comment.all.count # should be 2
+
+    my_copy = p.dup
+    my_copy.save
+
+    puts Comment.all.count # should be 4
+
+By default, when enabled, amoeba will copy any and all associated child records automatically and associated them with the new parent record.
+
+You can configure the behavior to only include fields that you list or to only include fields that you don't exclude. Of the three, the most performant will be the indiscriminate style, followed by the inclusive style, and the exclusive style will be the slowest because of the need for an extra explicit check on each field. This performance difference is likely negligible enough that you can choose the style to use based on which is easiest to read and write, however, if your data tree is large enough and you need control over what fields get copied, inclusive style is probably a better choice than exclusive style.
+
+## Configuration
+
+Please note that these examples are only loose approximations of real world scenarios and may not be particularly realistic, they are only for the purpose of demonstrating feature usage.
+
+### Indiscriminate Style
+
+This is the most basic usage case and will simply enable the copying of any known associations.
+
+If you have some models for a blog about like this:
+
+    class Post < ActiveRecord::Base
+      has_many :comments
+    end
+
+    class Comment < ActiveRecord::Base
+      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:
+
+    class Post < ActiveRecord::Base
+      has_many :comments
+
+      amoeba do
+        enable
+      end
+    end
+
+    class Comment < ActiveRecord::Base
+      belongs_to :post
+    end
+
+Child records will be automatically copied when you run the dup method.
+
+### Inclusive Style
+
+If you only want some of the associations copied but not others, you may use the inclusive style:
+
+    class Post < ActiveRecord::Base
+      has_many :comments
+      has_many :tags
+      has_many :authors
+
+      amoeba do
+        enable
+        include_field :tags
+        include_field :authors
+      end
+    end
+
+    class Comment < ActiveRecord::Base
+      belongs_to :post
+    end
+
+Using the inclusive style within the amoeba block actually implies that you wish to enable amoeba, so there is no need to run the enable method, though it won't hurt either:
+
+    class Post < ActiveRecord::Base
+      has_many :comments
+      has_many :tags
+      has_many :authors
+
+      amoeba do
+        include_field :tags
+        include_field :authors
+      end
+    end
+
+    class Comment < ActiveRecord::Base
+      belongs_to :post
+    end
+
+You may also specify fields to be copied by passing an array.
+
+    class Post < ActiveRecord::Base
+      has_many :comments
+      has_many :tags
+      has_many :authors
+
+      amoeba do
+        include_field [:tags, :authors]
+      end
+    end
+
+    class Comment < ActiveRecord::Base
+      belongs_to :post
+    end
+
+These examples will copy the post's tags and authors but not its comments.
+
+### 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:
+
+    class Post < ActiveRecord::Base
+      has_many :comments
+      has_many :tags
+      has_many :authors
+
+      amoeba do
+        exclude_field :comments
+      end
+    end
+
+    class Comment < ActiveRecord::Base
+      belongs_to :post
+    end
+
+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.
+
+### Limiting Association Types
+
+By default, amoeba recognizes and attemps to copy any children of the following association types:
+
+ - has one
+ - has many
+ - has and belongs to many
+
+You may control which association types amoeba applies itself to by using the `recognize` method within the amoeba configuration block.
+
+    class Post < ActiveRecord::Base
+      has_one :config
+      has_many :comments
+      has_and_belongs_to_many :tags
+
+      amoeba do
+        recognize [:has_one, :has_and_belongs_to_many]
+      end
+    end
+
+    class Comment < ActiveRecord::Base
+      belongs_to :post
+    end
+
+    class Tag < ActiveRecord::Base
+      has_and_belongs_to_many :posts
+    end
+
+This example will copy the post's configuration data and keep tags associated with the new post, but will not copy the post's comments because amoeba will only recognize and copy children of `has_one` and `has_and_belongs_to_many` associations and in this example, comments are not an `has_and_belongs_to_many` association.
+
+### Field Preprocessors
+
+#### Nullify
+
+If you wish to prevent a regular (non `has_*` association based) field from retaining it's value when copied, you may "zero out" or "nullify" the field, like this:
+
+    class Topic < ActiveRecord::Base
+      has_many :posts
+    end
+
+    class Post < ActiveRecord::Base
+      belongs_to :topic
+      has_many :comments
+
+      amoeba do
+        enable
+        nullify :date_published
+        nullify :topic_id
+      end
+    end
+
+    class Comment < ActiveRecord::Base
+      belongs_to :post
+    end
+
+This example will copy all of a post's comments. It will also nullify the publishing date and dissociate the post from its original topic.
+
+Unlike inclusive and exclusive styles, specifying null fields will not automatically enable amoeba to copy all child records. As with any active record object, the default field value will be used instead of `nil` if a default value exists on the migration.
+
+#### Prepend
+
+You may add a string to the beginning of a copied object's field during the copy phase:
+
+    class Post < ActiveRecord::Base
+      amoeba do
+        enable
+        prepend :title => "Copy of "
+      end
+    end
+
+#### Append
+
+You may add a string to the end of a copied object's field during the copy phase:
+
+    class Post < ActiveRecord::Base
+      amoeba do
+        enable
+        append :title => "Copy of "
+      end
+    end
+
+#### Regex
+
+You may run a search and replace query on a copied object's field during the copy phase:
+
+    class Post < ActiveRecord::Base
+      amoeba do
+        enable
+        regex :contents => {:replace => /dog/, :with => 'cat'}
+      end
+    end
+
+#### Chaining
+
+You may apply a preprocessor to multiple fields at once.
+
+    class Post < ActiveRecord::Base
+      amoeba do
+        enable
+        prepend :title => "Copy of ", :contents => "Copied contents: "
+      end
+    end
+
+#### Stacking
+
+You may apply multiple preproccessing directives to a single model at once.
+
+    class Post < ActiveRecord::Base
+      amoeba do
+        prepend :title => "Copy of ", :contents => "Original contents: "
+        append :contents => " (copied version)"
+        regex :contents => {:replace => /dog/, :with => 'cat'}
+      end
+    end
+
+This example should result in something like this:
+
+    post = Post.create(
+      :title => "Hello world",
+      :contents =>  "I like dogs, dogs are awesome."
+    )
+
+    new_post = post.dup
+
+    new_post.title # "Copy of Hello world"
+    new_post.contents # "Original contents: I like cats, cats are awesome. (copied version)"
+
+Like `nullify`, the preprocessing directives do not automatically enable the copying of associated child records. If only preprocessing directives are used and you do want to copy child records and no `include_field` or `exclude_field` list is provided, you must still explicitly enable the copying of child records by calling the enable method from within the amoeba block on your model.
+
+### Precedence
+
+You may use a combination of configuration methods within each model's amoeba block. Recognized association types take precedence over inclusion or exclusion lists. Inclusive style takes precedence over exclusive style, and these two explicit styles take precedence over the indiscriminate style. In other words, if you list fields to copy, amoeba will only copy the fields you list, or only copy the fields you don't exclude as the case may be. Additionally, if a field type is not recognized it will not be copied, regardless of whether it appears in an inclusion list. If you want amoeba to automatically copy all of your child records, do not list any fields using either `include_field` or `exclude_field`.
+
+The following example syntax is perfectly valid, and will result in the usage of inclusive style. The order in which you call the configuration methods within the amoeba block does not matter:
+
+    class Topic < ActiveRecord::Base
+      has_many :posts
+    end
+
+    class Post < ActiveRecord::Base
+      belongs_to :topic
+      has_many :comments
+      has_many :tags
+      has_many :authors
+
+      amoeba do
+        exclude_field :authors
+        include_field :tags
+        nullify :date_published
+        prepend :title => "Copy of "
+        append :contents => " (copied version)"
+        regex :contents => {:replace => /dog/, :with => 'cat'}
+        include_field :authors
+        enable
+        nullify :topic_id
+      end
+    end
+
+    class Comment < ActiveRecord::Base
+      belongs_to :post
+    end
+
+This example will copy all of a post's tags and authors, but not its comments. It will also nullify the publishing date and dissociate the post from its original topic. It will also preprocess the post's fields as in the previous preprocessing example.
+
+Note that, because of precedence, inclusive style is used and the list of exclude fields is never consulted. Additionally, the `enable` method is redundant because amoeba is automatically enabled when using `include_field`.
+
+The preprocessing directives are run after child records are copied andare run in this order.
+
+ 1. Null fields
+ 2. Prepends
+ 3. Appends
+ 4. Search and Replace
+
+Preprocessing directives do not affect inclusion and exclusion lists.
+
+### Recursing
+
+You may cause amoeba to keep copying down the chain as far as you like, simply add amoeba blocks to each model you wish to have copy its children. Amoeba will automatically recurse into any enabled grandchildren and copy them as well.
+
+    class Post < ActiveRecord::Base
+      has_many :comments
+
+      amoeba do
+        enable
+      end
+    end
+
+    class Comment < ActiveRecord::Base
+      belongs_to :post
+      has_many :ratings
+
+      amoeba do
+        enable
+      end
+    end
+
+    class Rating < ActiveRecord::Base
+      belongs_to :comment
+    end
+
+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.
+
+
+### On The Fly Configuration
+
+You may control how amoeba copies your object, on the fly, by passing a configuration block to the model's amoeba method. The configuration method is static but the configuration is applied on a per instance basis.
+
+    class Post < ActiveRecord::Base
+      has_many :comments
+
+      amoeba do
+        enable
+        prepend :title => "Copy of "
+      end
+    end
+
+    class Comment < ActiveRecord::Base
+      belongs_to :post
+    end
+
+    class PostsController < ActionController
+      def duplicate_a_post
+        old_post = Post.create(
+          :title => "Hello world",
+          :contents => "Lorum ipsum"
+        )
+
+        old_post.class.amoeba do
+          prepend :contents => "Here's a copy: "
+        end
+
+        new_post = old_post.dup
+
+        new_post.title # should be "Copy of Hello world"
+        new_post.contents # should be "Here's a copy: Lorum ipsum"
+        new_post.save
+      end
+    end
+
+### Config-Block Reference
+
+Here is a static reference to the available configuration methods, usable within the amoeba block on your rails models.
+
+`enable`
+
+Enables amoeba in the default style of copying all known associated child records.
+
+`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.
+
+`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.
+
+`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.
+
+`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.
+
+`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.
+
+`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"}`
+
+## 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.
+
+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.
+
+The behavior when copying nested hierarchical models is undefined. Copying a category model which has a `parent_id` field pointing to the parent category, for example, is currently undefined. The behavior when copying polymorphic `has_many` associations is also undefined. Support for these types of associations is planned for a future release.
+
+### For Developers
+
+You may run the rspec tests like this:
+
+    bundle exec rspec spec
+
+## TODO
+
+Write more tests.... anyone?

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/amoeba.gemspec

@@ -0,0 +1,29 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "amoeba/version"
+
+Gem::Specification.new do |s|
+  s.name        = "amoeba"
+  s.version     = Amoeba::VERSION
+  s.authors     = ["Vaughn Draughon"]
+  s.email       = "vaughn@rocksolidwebdesign.com"
+  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.}
+
+  s.rubyforge_project = "amoeba"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency "bundler", ">= 1.0.0"
+  s.add_development_dependency "rspec", "~> 2.3"
+
+  s.add_development_dependency "sqlite3-ruby"
+
+  s.add_dependency "activerecord", ">= 3.0"
+end

data/lib/amoeba.rb

@@ -0,0 +1,260 @@
+require "amoeba/version"
+
+module Amoeba
+  module ClassMethods
+    def amoeba(&block)
+      @config ||= Amoeba::ClassMethods::Config.new
+      @config.instance_eval(&block) if block_given?
+      @config
+    end
+
+    class Config
+      # Getters {{{
+      def enabled
+        @enabled ||= false
+        @enabled
+      end
+
+      def do_preproc
+        @do_preproc ||= false
+        @do_preproc
+      end
+
+      def includes
+        @includes ||= []
+        @includes
+      end
+
+      def excludes
+        @excludes ||= []
+        @excludes
+      end
+
+      def known_macros
+        @known_macros ||= [:has_one, :has_many, :has_and_belongs_to_many]
+        @known_macros
+      end
+
+      def null_fields
+        @null_fields ||= []
+        @null_fields
+      end
+
+      def prefixes
+        @prefixes ||= {}
+        @prefixes
+      end
+
+      def suffixes
+        @suffixes ||= {}
+        @suffixes
+      end
+
+      def regexes
+        @regexes ||= {}
+        @regexes
+      end
+      # }}}
+
+      # Setters (Config DSL) {{{
+      def enable
+        @enabled = true
+      end
+
+      def disable
+        @enabled = false
+      end
+
+      def include_field(value=nil)
+        @enabled ||= true
+        @includes ||= []
+        if value.is_a?(Array)
+          @includes = value
+        else
+          @includes << value if value
+        end
+        @includes
+      end
+
+      def exclude_field(value=nil)
+        @enabled ||= true
+        @excludes ||= []
+        if value.is_a?(Array)
+          @excludes = value
+        else
+          @excludes << value if value
+        end
+        @excludes
+      end
+
+      def recognize(value=nil)
+        @enabled ||= true
+        @known_macros ||= []
+        if value.is_a?(Array)
+          @known_macros = value
+        else
+          @known_macros << value if value
+        end
+        @known_macros
+      end
+
+      def nullify(value=nil)
+        @do_preproc ||= true
+        @null_fields ||= []
+        if value.is_a?(Array)
+          @null_fields = value
+        else
+          @null_fields << value if value
+        end
+        @null_fields
+      end
+
+      def prepend(defs=nil)
+        @do_preproc ||= true
+        @prefixes ||= {}
+        if defs.is_a?(Array)
+          @prefixes = {}
+
+          defs.each do |d|
+            d.each do |k,v|
+              @prefixes[k] = v if v
+            end
+          end
+        else
+          defs.each do |k,v|
+            @prefixes[k] = v if v
+          end
+        end
+        @prefixes
+      end
+
+      def append(defs=nil)
+        @do_preproc ||= true
+        @suffixes ||= {}
+        if defs.is_a?(Array)
+          @suffixes = {}
+
+          defs.each do |d|
+            d.each do |k,v|
+              @suffixes[k] = v if v
+            end
+          end
+        else
+          defs.each do |k,v|
+            @suffixes[k] = v if v
+          end
+        end
+        @suffixes
+      end
+
+      def regex(defs=nil)
+        @do_preproc ||= true
+        @regexes ||= {}
+        if defs.is_a?(Array)
+          @regexes = {}
+
+          defs.each do |d|
+            d.each do |k,v|
+              @regexes[k] = v if v
+            end
+          end
+        else
+          defs.each do |k,v|
+            @regexes[k] = v if v
+          end
+        end
+        @regexes
+      end
+      # }}}
+    end
+  end
+
+  module InstanceMethods
+    def amoeba_conf
+      self.class.amoeba
+    end
+
+    def amo_process_association(relation_name, settings)
+      if not amoeba_conf.known_macros.include?(settings.macro)
+        return
+      end
+
+      case settings.macro
+      when :has_one
+        old_obj = self.send(relation_name)
+
+        copy_of_obj = old_obj.dup
+        copy_of_obj[:"#{settings.foreign_key}"] = nil
+
+        @result.send(:"#{relation_name}=", copy_of_obj)
+      when :has_many
+        self.send(relation_name).each do |old_obj|
+          copy_of_obj = old_obj.dup
+          copy_of_obj[:"#{settings.foreign_key}"] = nil
+
+          # associate this new child to the new parent object
+          @result.send(relation_name) << copy_of_obj
+        end
+      when :has_and_belongs_to_many
+        self.send(relation_name).each do |old_obj|
+          # associate this new child to the new parent object
+          @result.send(relation_name) << old_obj
+        end
+      end
+    end
+
+    def dup(options={})
+      @result = super()
+
+      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
+      # nullify any fields the user has configured
+      amoeba_conf.null_fields.each do |n|
+        @result[n] = nil
+      end
+
+      # prepend any extra strings to indicate uniqueness of the new record(s)
+      amoeba_conf.prefixes.each do |field,prefix|
+        @result[field] = "#{prefix}#{@result[field]}"
+      end
+
+      # postpend any extra strings to indicate uniqueness of the new record(s)
+      amoeba_conf.suffixes.each do |field,suffix|
+        @result[field] = "#{@result[field]}#{suffix}"
+      end
+
+      # regex andy fields that need changing
+      amoeba_conf.regexes.each do |field,action|
+        @result[field].gsub!(action[:replace], action[:with])
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :extend,  Amoeba::ClassMethods
+ActiveRecord::Base.send :include, Amoeba::InstanceMethods

data/lib/amoeba/version.rb

@@ -0,0 +1,3 @@
+module Amoeba
+  VERSION = "0.0.1"
+end

data/spec/lib/amoeba_spec.rb

@@ -0,0 +1,45 @@
+require 'active_record'
+require 'spec_helper'
+
+describe "amoeba" do
+  context "dup" do
+    it "duplicates associated child records" do
+      old_post = Post.find(1)
+      old_post.comments.map(&:contents).include?("I love it!").should be true
+
+      old_post.class.amoeba do
+        prepend :contents => "Here's a copy: "
+      end
+
+      new_post = old_post.dup
+
+      start_tag_count = Tag.all.count
+      start_post_count = Post.all.count
+      start_comment_count = Comment.all.count
+      start_rating_count = Rating.all.count
+      start_postconfig_count = PostConfig.all.count
+      rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS tag_count FROM posts_tags')
+      start_posttag_count = rs["tag_count"]
+
+      new_post.save
+
+      end_tag_count = Tag.all.count
+      end_post_count = Post.all.count
+      end_comment_count = Comment.all.count
+      end_rating_count = Rating.all.count
+      end_postconfig_count = PostConfig.all.count
+      rs = ActiveRecord::Base.connection.select_one('SELECT COUNT(*) AS tag_count FROM posts_tags')
+      end_posttag_count = rs["tag_count"]
+
+      end_tag_count.should         == start_tag_count
+      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.title.should == "Copy of #{old_post.title}"
+      new_post.contents.should == "Here's a copy: #{old_post.contents.gsub(/dog/, 'cat')} (copied version)"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+require 'amoeba'
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3",
+                                       :database => File.dirname(__FILE__) + "/test.sqlite3")
+
+load File.dirname(__FILE__) + '/support/schema.rb'
+load File.dirname(__FILE__) + '/support/models.rb'
+load File.dirname(__FILE__) + '/support/data.rb'

data/spec/support/data.rb

@@ -0,0 +1,41 @@
+u1 = User.create(:name => "Robert Johnson", :email => "bob@crossroads.com")
+u2 = User.create(:name => "Miles Davis", :email => "miles@kindofblue.com")
+
+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')
+c1 = p1.comments.create(:contents => "I love it!")
+c1.ratings.create(:num_stars => 5)
+c1.ratings.create(:num_stars => 5)
+c1.ratings.create(:num_stars => 4)
+c1.ratings.create(:num_stars => 3)
+c1.ratings.create(:num_stars => 5)
+c1.ratings.create(:num_stars => 5)
+
+c2 = p1.comments.create(:contents => "I hate it!")
+c2.ratings.create(:num_stars => 3)
+c2.ratings.create(:num_stars => 1)
+c2.ratings.create(:num_stars => 4)
+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.ratings.create(:num_stars => 0)
+c3.ratings.create(:num_stars => 0)
+c3.ratings.create(:num_stars => 1)
+c3.ratings.create(:num_stars => 2)
+c3.ratings.create(:num_stars => 1)
+c3.ratings.create(:num_stars => 0)
+
+t1 = Tag.create(:value => "funny")
+t2 = Tag.create(:value => "wtf")
+t3 = Tag.create(:value => "cats")
+
+p1.tags << t1
+p1.tags << t2
+p1.tags << t3
+p1.save
+# }}}

data/spec/support/models.rb

@@ -0,0 +1,43 @@
+class Topic < ActiveRecord::Base
+  has_many :posts
+end
+
+class Post < ActiveRecord::Base
+  belongs_to :topic
+  belongs_to :author, :class_name => 'User'
+  has_one :post_config
+  has_many :comments
+  has_and_belongs_to_many :tags
+
+  amoeba do
+    enable
+    prepend :title => "Copy of "
+    append :contents => " (copied version)"
+    regex :contents => {:replace => /dog/, :with => 'cat'}
+  end
+end
+
+class PostConfig < ActiveRecord::Base
+  belongs_to :post
+end
+
+class Comment < ActiveRecord::Base
+  belongs_to :post
+  has_many :ratings
+
+  amoeba do
+    enable
+  end
+end
+
+class Rating < ActiveRecord::Base
+  belongs_to :comment
+end
+
+class Tag < ActiveRecord::Base
+  has_and_belongs_to_many :posts
+end
+
+class User < ActiveRecord::Base
+  has_many :posts
+end

data/spec/support/schema.rb

@@ -0,0 +1,61 @@
+ActiveRecord::Schema.define do
+  self.verbose = false
+
+  create_table :topics, :force => true do |t|
+    t.string :title
+    t.string :description
+    t.timestamps
+  end
+
+  create_table :posts, :force => true do |t|
+    t.integer :topic_id
+    t.integer :author_id
+    t.string :title
+    t.string :contents
+    t.timestamps
+  end
+
+  create_table :post_configs, :force => true do |t|
+    t.integer :post_id
+    t.integer :is_visible
+    t.integer :is_open
+    t.string :password
+    t.timestamps
+  end
+
+  create_table :comments, :force => true do |t|
+    t.integer :post_id
+    t.string :contents
+    t.timestamps
+  end
+
+  create_table :comments, :force => true do |t|
+    t.integer :post_id
+    t.string :contents
+    t.timestamps
+  end
+
+  create_table :ratings, :force => true do |t|
+    t.integer :comment_id
+    t.string :num_stars
+    t.timestamps
+  end
+
+  create_table :tags, :force => true do |t|
+    t.integer :post_id
+    t.string :value
+    t.timestamps
+  end
+
+  create_table :users, :force => true do |t|
+    t.integer :post_id
+    t.string :name
+    t.string :email
+    t.timestamps
+  end
+
+  create_table :posts_tags, :force => true do |t|
+    t.integer :post_id
+    t.integer :tag_id
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: amoeba
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Vaughn Draughon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &20942620 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *20942620
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &20941880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.3'
+  type: :development
+  prerelease: false
+  version_requirements: *20941880
+- !ruby/object:Gem::Dependency
+  name: sqlite3-ruby
+  requirement: &20940660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *20940660
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: &20956240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *20956240
+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.
+email: vaughn@rocksolidwebdesign.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc
+- Gemfile
+- README.md
+- Rakefile
+- amoeba.gemspec
+- lib/amoeba.rb
+- lib/amoeba/version.rb
+- 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
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: amoeba
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Easy copying of rails models and their child associations.
+test_files: []