acts_as_edition 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 388edb3ce642edfbaf91712cc920565da99eeea0
+  data.tar.gz: 5e0c5d7465099a15ddd8da0af55acd76c43d391e
+SHA512:
+  metadata.gz: e5a69c47e155918e75720f5ad38017d3f0fb1046df4089cdb248c5615f95bfbb0425cf1353b7c86857600a100bb3ed1d1cceafa8a7524e7a4a38f8dcf1edcb89
+  data.tar.gz: e7a587b15fe382e379e0e6f66f72d6592d7232ca4d25f524ab63f61c23b9cd64e097537d549a247028289d9f994f2b6a48389bca5a811a223c953ac6bdbd8535

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

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

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Virginia Department of Education
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,114 @@
+ActsAsEdition
+=============
+
+acts_as_edition is a ruby gem for creating new editions of a tree (think
+document) of ActiveRecord models.
+
+Each new edition tree is a deep clone of the previous tree. The edition tree is
+defined using an acts_as_edition declaration on each model in the tree.  Using
+the resources option, acts_as_edition supports management of relationships
+between models in the edition tree and those outside it. A selection of hooks
+provide additional control over the cloning process.  Conditions can be
+specified on models in the tree to determine when/if they are cloned. Finally,
+each object in the tree maintains a simple belongs_to relationship with its
+ancestor in the previous edition.
+
+If you are considering acts_as_edition, you should also evaluate
+acts_as_versioned and deep_cloning:
+
+http://github.com/technoweenie/acts_as_versioned
+http://github.com/DefV/deep_cloning
+
+Install
+=======
+
+gem install acts_as_versioned
+
+Example
+=======
+
+First, add ancestor_id column to every table in the tree, using a migration
+thusly:
+
+class AddEditionMigration < ActiveRecord::Migration
+  def self.up
+    add_column :mymodel, :ancestor_id, :integer
+  end
+
+  def self.down
+    remove_column :mymodel, :ancestor_id
+  end
+end
+
+rake db:migrate
+
+Then declare acts_as_edition in the model class:
+
+class Guide < ActiveRecord::Base
+  acts_as_edition :edition_chain => [:abbreviation, :imprint, :places],
+                  :resources => [:country, :retailers, :authors],
+                  :pre_hook => :unpublish_self,
+                  :after_clone => :increment_descendant_year,
+                  :post_hook => :publish_descendant
+                  :conditions => { :returns_true => true }
+  has_one :abbreviation
+  belongs_to :imprint
+  has_many :places
+  has_one :country
+  has_many :retailers
+  has_and_belongs_to_many :authors
+
+protected
+
+  def unpublish_self
+    self.published = false
+    self.save!
+  end
+
+  def increment_descendant_year
+    self.year = (self.year.to_i + 1).to_s
+    self.save!
+  end
+
+  def publish_descendant
+    self.descendant.published = true
+    self.descendant.save!
+  end
+
+  def returns_true
+    name != 'Noclonelandia'
+  end
+end
+
+class Abbreviation < ActiveRecord::Base
+  . . .
+end
+
+And so on -- these models are taken from the tests if you need more context.
+
+To clone:
+
+new_edition = Guide.first.clone_edition!
+new_edition.ancestor # == Guide.first
+Guide.first.descendant # == new_edition
+
+Attributes listed in edition_chain are cloned. Note that their model classes
+must also have acts_as_edition declarations.
+
+Atributes listed in resources are not cloned. The relationship between these
+resource objects and objects in the previous edition tree are reestablished in
+the new edition tree. NOTE: the relatishionship of the resource to the original
+object may be broken. The exception is resources in a habtm relationship with
+edition objects. In these cases, the relationship to the new edition is
+additive.
+
+pre_hook and post_hook are called at the beginning and end of the process on
+the original object. The after_clone hook is called *on the newly cloned
+object* before it is saved to the database.
+
+If an object does not meet all conditions specified in the conditions
+options hash, clone_edition! on that object will return nil and the object will
+not be copied into the new tree.
+
+Copyright (c) 2010, 2013 Virginia Department of Education, released under the MIT
+license

data/Rakefile

@@ -0,0 +1,24 @@
+require "bundler/gem_tasks"
+require 'rake'
+require 'rake/testtask'
+require 'rdoc/task'
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the acts_as_edition plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the acts_as_edition plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'ActsAsEdition'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/acts_as_edition.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'acts_as_edition/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "acts_as_edition"
+  spec.version       = ActsAsEdition::VERSION
+  spec.authors       = ["Lee Capps"]
+  spec.email         = ["himself@leecapps.com"]
+  spec.description   = %q{Editions for ActiveRecord models}
+  spec.summary       = %q{acts_as_edition is a ruby gem for creating new editions of trees of ActiveRecord objects.}
+  spec.homepage      = "https://github.com/jlcapps/acts_as_edition"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency('activerecord', ["~> 3.2.13"])
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "sqlite3"
+end

data/init.rb

@@ -0,0 +1,3 @@
+require 'acts_as_edition'
+
+ActiveRecord::Base.extend ActsAsEdition

data/lib/acts_as_edition/version.rb

@@ -0,0 +1,3 @@
+module ActsAsEdition
+  VERSION = "1.0.0"
+end

data/lib/acts_as_edition.rb

@@ -0,0 +1,95 @@
+# ActsAsEdition
+module ActsAsEdition
+   # :pre_hook and :post_hook run on the original object. :after_clone
+   # runs on the cloned object before it is saved.
+   # Attributes listed in :edition_chain are cloned and related to
+   # self.descendant. Those listed in :resources are related to the
+   # self.descendant and are otherwise left as is.
+   # NOTE: habtm realtionships are handled differently from other
+   # resources. For the resource, the change is additive. The resource
+   # will have a relationship with original *and* cloned edition object.
+   def acts_as_edition(options = {})
+    belongs_to :ancestor, :class_name => name, :foreign_key => :ancestor_id
+    has_one :descendant, :class_name => name, :foreign_key => :ancestor_id
+
+    cattr_accessor :edition_chain, :resources, :pre_hook, :after_clone,
+                   :post_hook, :conditions
+    self.edition_chain = Array((options[:edition_chain] || []))
+    self.resources = Array((options[:resources] || []))
+    self.pre_hook = options[:pre_hook]
+    self.after_clone = options[:after_clone]
+    self.post_hook = options[:post_hook]
+    self.conditions = (options[:conditions] || {})
+
+    include InstanceMethods
+  end
+
+  module InstanceMethods
+    def clone_edition!
+      self.class.transaction do
+        self.send("#{self.pre_hook}") if self.pre_hook
+        cloned = ActiveRecord::VERSION::MAJOR==3 ? self.dup : self.clone
+        cloned.send("#{self.after_clone}") if self.after_clone
+        cloned.ancestor = self
+        cloned.save!
+        self.reload
+        clone_edition_chain
+        clone_resource_chain
+        self.send("#{self.post_hook}") if self.post_hook
+        cloned.save!
+        cloned.reload
+      end if aae_conditions_met
+    end
+
+  protected
+
+    def aae_conditions_met
+      self.conditions.keys.collect do |k|
+        self.send(k) == self.conditions[k]
+      end.all?
+    end
+
+    def clone_edition_chain
+      self.edition_chain.each do |association|
+        case self.class.reflect_on_association(association).macro
+        when :has_one, :belongs_to
+          cloned = (self.send(association) &&
+                    (self.send(association).descendant ||
+                     self.send(association).clone_edition!))
+          self.descendant.send("#{association}=", cloned) unless cloned.nil?
+          self.descendant.save!
+        when :has_many, :has_and_belongs_to_many
+          self.send(association) && self.send(association).each do |associated|
+            cloned = associated.descendant || associated.clone_edition!
+            unless (self.descendant.send("#{association}").include?(cloned) ||
+                    cloned.nil?)
+              self.descendant.send("#{association}") << cloned
+              self.descendant.save!
+            end
+          end
+       end
+      end
+    end
+
+    def clone_resource_chain
+      self.reload
+      self.resources.reject { |r| r.to_s.empty? }.each do |association|
+        case self.class.reflect_on_association(association).macro
+        when :has_one
+          resource = self.send(association)
+          self.descendant.send("#{association}=", resource)
+          self.descendant.save!
+        when :has_many, :has_and_belongs_to_many
+          resources = self.send(association)
+          resources.each do |resource|
+            self.descendant.send("#{association}") << resource
+          end
+          self.descendant.save!
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.extend ActsAsEdition
+

data/test/acts_as_edition_test.rb

@@ -0,0 +1,219 @@
+require 'test_helper'
+
+class ActsAsEditionTest < ActiveSupport::TestCase
+  fixtures :all
+
+  test "should respond to #ancestor" do
+    assert_respond_to Guide.new, :ancestor
+  end
+
+  test "should respond to #descendant" do
+    assert_respond_to Guide.new, :descendant
+  end
+
+  test "#ancestor and #descendant work as expected" do
+    guide = guides(:scotland)
+    cloned = guide.clone
+    cloned.ancestor = guide
+    cloned.save!
+    assert_equal cloned.ancestor, guide
+    assert_equal guide.descendant, cloned
+  end
+
+  test "should respond to #clone_edition!" do
+    assert_respond_to guides(:scotland), :clone_edition!
+  end
+
+  test "#clone_edition! clones edition" do
+    orig = guides(:scotland)
+    cloned = orig.clone_edition!
+    assert_equal cloned.ancestor, orig
+    assert_equal orig.descendant, cloned
+    assert_equal orig.name, cloned.name
+  end
+
+  test ":edition_chain and :resources options are stored as class attrs" do
+    assert_respond_to guides(:scotland), :edition_chain
+    assert guides(:scotland).edition_chain.include? :abbreviation
+    assert_respond_to Law.new, :resources
+  end
+
+  test ":conditions is stored as class attr" do
+    assert_respond_to guides(:scotland), :conditions
+    assert guides(:scotland).conditions.keys.include? :returns_true
+  end
+
+  test "should not clone if conditions not met" do
+    assert_equal guides(:noclonelandia).clone_edition!, nil
+  end
+
+  test "guide and abbreviation are properly related" do
+    assert_equal guides(:scotland).abbreviation, abbreviations(:sco)
+  end
+
+  test "should clone has_one specified in edition_chain" do
+    orig = guides(:scotland)
+    cloned = orig.clone_edition!
+    assert_equal orig.abbreviation, cloned.abbreviation.ancestor
+    assert_equal orig.abbreviation.descendant, cloned.abbreviation
+  end
+
+  test "should not clone has_one in edition_chain if conditions not met" do
+    orig = guides(:england)
+    cloned = orig.clone_edition!
+    assert_equal orig.abbreviation.descendant, nil
+    assert_equal cloned.abbreviation, nil
+  end
+
+  test "should clone belongs_to specified in edition_chain" do
+    orig = guides(:scotland)
+    cloned = orig.clone_edition!
+    orig.reload
+    cloned.reload
+    assert_equal orig.imprint, orig.descendant.imprint.ancestor
+    assert_equal cloned.imprint, orig.imprint.descendant
+    assert orig.imprint.descendant.guides.include? orig.descendant
+  end
+
+  test "should maintain belongs_to relationship in resources" do
+    orig = guides(:scotland)
+    cloned = orig.clone_edition!
+    orig.reload
+    cloned.reload
+    assert_equal orig.abbreviation.alphabet.id,
+      orig.descendant.abbreviation.alphabet.id
+  end
+
+  test "should clone has_manys specified in edition_chain" do
+    orig = guides(:scotland)
+    cloned = orig.clone_edition!
+    orig.reload
+    cloned.reload
+    orig.places.select { |p| p.cloneme? }.each do |place|
+      assert cloned.places.include? place.descendant
+      assert_equal place.descendant.guide, cloned
+    end
+    cloned.places.each do |place|
+      assert orig.places.include? place.ancestor
+      assert_equal place.ancestor.guide, orig
+    end
+  end
+
+  test "should not clone edition_chain has_manys if conditions not met" do
+    orig = guides(:scotland)
+    cloned = orig.clone_edition!
+    orig.reload
+    cloned.reload
+    assert_equal orig.places.count, cloned.places.count + 1
+    orig.places.select { |p| !p.cloneme? }.each do |place|
+      assert !cloned.places.include?(place)
+    end
+  end
+
+  test "should clone nested has_manys" do
+    orig = guides(:scotland)
+    cloned = orig.clone_edition!
+    orig.reload
+    cloned.reload
+    orig_maps_count = cloned_maps_count = 0
+    orig.places.each { |place| orig_maps_count += place.maps.count }
+    cloned.places.each { |place| cloned_maps_count += place.maps.count }
+    assert_equal orig_maps_count, cloned_maps_count
+    cloned.places.each do |place|
+      place.maps.each do |map|
+        assert place.ancestor.maps.include? map.ancestor
+      end
+    end
+  end
+
+  test "should clone has_and_belongs_to_manys specified in edition_chain" do
+    orig = guides(:scotland)
+    cloned = orig.clone_edition!
+    orig.reload
+    cloned.reload
+    orig_laws = cloned_laws = []
+    orig.places.each do |place|
+      orig_laws += place.laws.select { |l| l.cloneme? }
+    end
+    cloned.places.
+      each { |place| cloned_laws += place.laws.select { |l| l.cloneme? } }
+    assert_equal orig_laws.count, cloned_laws.count
+    orig_laws.each do |orig_law|
+      assert_equal 1, Law.find_all_by_ancestor_id(orig_law.id).count
+      assert !cloned_laws.include?(orig_law)
+      assert cloned_laws.include?(orig_law.descendant)
+      orig_law.places.each do |orig_place|
+        assert !orig_law.descendant.places.include?(orig_place)
+      end
+    end
+    cloned_laws.each do |cloned_law|
+      assert orig_laws.include?(cloned_law.ancestor)
+    end
+  end
+
+  test "should update relationship to has_ones spec'd in resources" do
+    # XXX this is a contrived case; would probably want to clone . . .
+    orig = guides(:scotland)
+    country = orig.country
+    cloned = orig.clone_edition!
+    orig.reload
+    cloned.reload
+    assert_equal orig.country, nil
+    assert_equal cloned.country, country
+  end
+
+  test "should updated relationship to has_manys spec'd in resources" do
+    orig = guides(:scotland)
+    retailer_ids = orig.retailers.collect { |r| r.id }
+    cloned = orig.clone_edition!
+    orig.reload
+    assert_equal 0, orig.retailers.count
+    assert_equal retailer_ids.count, cloned.retailers.count
+    cloned.retailers.each do |retailer|
+      assert retailer_ids.include?(retailer.id)
+    end
+    cloned_ids = cloned.retailers.collect { |r| r.id }
+    retailer_ids.each do |id|
+      assert cloned_ids.include?(id)
+    end
+  end
+
+  test "should update relationship to has_and_belongs_to_many resources" do
+    # habtm realtionships are handled differently from other resources.
+    # For the resource, the change is additive. The resource will have
+    # a relationship with original *and* cloned edition object.
+    orig = guides(:scotland)
+    author_ids = orig.authors.collect { |a| a.id }
+    cloned = orig.clone_edition!
+    orig.reload
+    assert_equal cloned.authors.count, orig.authors.count
+    assert_equal cloned.authors.first.guides.count, 2
+    orig.authors.each { |author| assert cloned.authors.include?(author) }
+    cloned.authors.each { |author| assert orig.authors.include?(author) }
+  end
+
+  test "should execute pre_hook" do
+    orig = guides(:scotland)
+    assert orig.published?
+    cloned = orig.clone_edition!
+    orig.reload
+    assert !orig.published?
+  end
+
+  test "should execute after_clone" do
+    orig = guides(:scotland)
+    orig_year = orig.year.to_i
+    cloned = orig.clone_edition!
+    orig.reload
+    assert_equal orig_year + 1, cloned.year.to_i
+    assert_equal orig.year.to_i, orig_year
+  end
+
+  test "should execute post_hook" do
+    orig = guides(:scotland)
+    cloned = orig.clone_edition!
+    orig.reload
+    assert !orig.published?
+    assert cloned.published?
+  end
+end

data/test/database.yml

@@ -0,0 +1,3 @@
+sqlite3:
+  adapter: sqlite3
+  database: ":memory:"

data/test/fixtures/abbreviation.rb

@@ -0,0 +1,6 @@
+class Abbreviation < ActiveRecord::Base
+  acts_as_edition :resources => [:alphabet],
+                  :conditions => { :cloneme? => true }
+  belongs_to :guide
+  belongs_to :alphabet
+end

data/test/fixtures/abbreviations.yml

@@ -0,0 +1,11 @@
+sco:
+  name: SCO
+  guide: scotland 
+  alphabet: latin
+  cloneme: true
+
+eng:
+  name: ENG
+  guide: england
+  alphabet: latin
+  cloneme: false

data/test/fixtures/alphabet.rb

@@ -0,0 +1,2 @@
+class Alphabet < ActiveRecord::Base
+end

data/test/fixtures/alphabets.yml

@@ -0,0 +1,2 @@
+latin:
+  name: Latin

data/test/fixtures/author.rb

@@ -0,0 +1,3 @@
+class Author < ActiveRecord::Base
+  has_and_belongs_to_many :guides
+end

data/test/fixtures/authors.yml

@@ -0,0 +1,8 @@
+laura:
+  name: Laura
+
+darren:
+  name: Darren
+
+mary:
+  name: Mary

data/test/fixtures/countries.yml

@@ -0,0 +1,3 @@
+scotland_country:
+  name: Scotland
+  guide: scotland

data/test/fixtures/country.rb

@@ -0,0 +1,3 @@
+class Retailer < ActiveRecord::Base
+  belongs_to :guide
+end

data/test/fixtures/guide.rb

@@ -0,0 +1,35 @@
+class Guide < ActiveRecord::Base
+  acts_as_edition :edition_chain => [:abbreviation, :imprint, :places],
+                  :resources => [:country, :retailers, :authors],
+                  :pre_hook => :unpublish_self,
+                  :after_clone => :increment_descendant_year,
+                  :post_hook => :publish_descendant,
+                  :conditions => { :returns_true => true }
+  has_one :abbreviation
+  belongs_to :imprint
+  has_many :places
+  has_one :country
+  has_many :retailers
+  has_and_belongs_to_many :authors
+
+protected
+
+  def unpublish_self
+    self.published = false
+    self.save!
+  end
+
+  def increment_descendant_year
+    self.year = (self.year.to_i + 1).to_s
+    self.save!
+  end
+
+  def publish_descendant
+    self.descendant.published = true
+    self.descendant.save!
+  end
+
+  def returns_true
+    name != 'Noclonelandia'
+  end
+end

data/test/fixtures/guides.yml

@@ -0,0 +1,20 @@
+scotland:
+  name: Scotland
+  imprint: fodors
+  published: true
+  year: 2009
+  authors: mary, darren, laura
+
+noclonelandia:
+  name: Noclonelandia
+  imprint: fodors
+  published: true
+  year: 2009
+  authors: lee
+
+england:
+  name: England
+  imprint: fodors
+  published: true
+  year: 2009
+  authors: peggy

data/test/fixtures/imprint.rb

@@ -0,0 +1,4 @@
+class Imprint < ActiveRecord::Base
+  acts_as_edition
+  has_many :guides
+end

data/test/fixtures/imprints.yml

@@ -0,0 +1,2 @@
+fodors:
+  name: Fodors

data/test/fixtures/law.rb

@@ -0,0 +1,6 @@
+class Law < ActiveRecord::Base
+  acts_as_edition :edition_chain => [], :resources => '', 
+                  :conditions => { :cloneme? => true }
+  has_and_belongs_to_many :places
+
+end

data/test/fixtures/laws.yml

@@ -0,0 +1,12 @@
+edinburg_law:
+  name: No left on red
+  places: edinburgh
+
+national:
+  name: Drive on the wrong side of the road
+  places: edinburgh, glasgow
+
+common:
+  name: Common law
+  places: glasgow
+  cloneme: false

data/test/fixtures/map.rb

@@ -0,0 +1,4 @@
+class Map < ActiveRecord::Base
+  acts_as_edition
+  belongs_to :place
+end

data/test/fixtures/maps.yml

@@ -0,0 +1,3 @@
+hwy:
+  name: Highway Map
+  place: edinburgh

data/test/fixtures/place.rb

@@ -0,0 +1,7 @@
+class Place < ActiveRecord::Base
+  acts_as_edition :edition_chain => [:maps, :laws],
+                  :conditions => { :cloneme? => true }
+  belongs_to :guide
+  has_many :maps
+  has_and_belongs_to_many :laws
+end

data/test/fixtures/places.yml

@@ -0,0 +1,12 @@
+edinburgh:
+  name: Edinburgh
+  guide: scotland
+
+glasgow:
+  name: Glasgow
+  guide: scotland
+
+aberdeen:
+  name: Aberdeen
+  guide: scotland
+  cloneme: false

data/test/fixtures/retailer.rb

@@ -0,0 +1,3 @@
+class Country < ActiveRecord::Base
+  belongs_to :guide
+end

data/test/fixtures/retailers.yml

@@ -0,0 +1,7 @@
+amazon:
+  name: Amazon UK
+  guide: scotland
+
+waterstones:
+  name: "Waterstone's"
+  guide: scotland

data/test/schema.rb

@@ -0,0 +1,69 @@
+ActiveRecord::Schema.define(:version => 1) do
+  create_table :guides, :force => true do |t|
+    t.column :name, :string
+    t.column :ancestor_id, :integer, :default => nil
+    t.column :imprint_id, :integer, :default => nil
+    t.column :published, :boolean, :default => false
+    t.column :year, :string
+  end
+  
+  create_table :places, :force => true do |t|
+    t.column :name, :string
+    t.column :guide_id, :integer
+    t.column :ancestor_id, :integer, :default => nil
+    t.column :cloneme, :boolean, :default => true
+  end
+
+  create_table :laws, :force => true do |t|
+    t.column :name, :string
+    t.column :ancestor_id, :integer, :default => nil
+    t.column :cloneme, :boolean, :default => true
+  end
+
+  create_table "laws_places", :id => false, :force => true do |t|
+    t.integer "place_id"
+    t.integer "law_id"
+  end
+   
+  create_table :maps, :force => true do |t|
+    t.column :name, :string
+    t.column :place_id, :integer
+    t.column :ancestor_id, :integer, :default => nil
+  end
+
+  create_table :alphabets, :force => true do |t|
+    t.column :name, :string
+  end
+
+  create_table :abbreviations, :force => true do |t|
+    t.column :name, :string
+    t.column :alphabet_id, :integer
+    t.column :guide_id, :integer
+    t.column :ancestor_id, :integer, :default => nil
+    t.column :cloneme, :boolean, :default => true
+  end 
+
+  create_table :imprints, :force=> true do |t|
+    t.column :name, :string
+    t.column :ancestor_id, :integer, :default => nil
+  end
+
+  create_table :countries, :force=> true do |t|
+    t.column :name, :string
+    t.column :guide_id, :integer, :default => nil
+  end
+
+  create_table :retailers, :force=> true do |t|
+    t.column :name, :string
+    t.column :guide_id, :integer, :default => nil
+  end
+
+  create_table :authors, :force=> true do |t|
+    t.column :name, :string
+  end
+
+  create_table "authors_guides", :id => false, :force => true do |t|
+    t.integer "author_id"
+    t.integer "guide_id"
+  end
+ end

data/test/test_helper.rb

@@ -0,0 +1,38 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+RAILS_ROOT = File.dirname(__FILE__)
+
+require 'active_record'
+require 'active_record/fixtures'
+require 'active_support'
+require 'active_support/test_case'
+require 'rubygems'
+require 'test/unit'
+
+require "#{File.dirname(__FILE__)}/../init"
+
+config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
+ActiveRecord::Base.configurations = { "test" => config[ENV['DB'] || 'sqlite3'] }
+ActiveRecord::Base.establish_connection(
+  ActiveRecord::Base.configurations['test']
+)
+ 
+load(File.dirname(__FILE__) + "/schema.rb")
+ 
+class ActiveSupport::TestCase #:nodoc:
+  include ActiveRecord::TestFixtures
+  self.fixture_path = File.dirname(__FILE__) + "/fixtures/"
+  $LOAD_PATH.unshift(self.fixture_path)
+  def create_fixtures(*table_names)
+    if block_given?
+      Fixtures.create_fixtures(self.fixture_path, 
+        table_names
+      ) { yield }
+    else
+      Fixtures.create_fixtures(self.fixture_path, table_names)
+    end
+  end
+ 
+  self.use_transactional_fixtures = true
+  self.use_instantiated_fixtures  = false
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: acts_as_edition
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Lee Capps
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Editions for ActiveRecord models
+email:
+- himself@leecapps.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- MIT-LICENSE
+- README
+- Rakefile
+- acts_as_edition.gemspec
+- init.rb
+- lib/acts_as_edition.rb
+- lib/acts_as_edition/version.rb
+- test/acts_as_edition_test.rb
+- test/database.yml
+- test/fixtures/abbreviation.rb
+- test/fixtures/abbreviations.yml
+- test/fixtures/alphabet.rb
+- test/fixtures/alphabets.yml
+- test/fixtures/author.rb
+- test/fixtures/authors.yml
+- test/fixtures/countries.yml
+- test/fixtures/country.rb
+- test/fixtures/guide.rb
+- test/fixtures/guides.yml
+- test/fixtures/imprint.rb
+- test/fixtures/imprints.yml
+- test/fixtures/law.rb
+- test/fixtures/laws.yml
+- test/fixtures/map.rb
+- test/fixtures/maps.yml
+- test/fixtures/place.rb
+- test/fixtures/places.yml
+- test/fixtures/retailer.rb
+- test/fixtures/retailers.yml
+- test/schema.rb
+- test/test_helper.rb
+homepage: https://github.com/jlcapps/acts_as_edition
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: acts_as_edition is a ruby gem for creating new editions of trees of ActiveRecord
+  objects.
+test_files:
+- test/acts_as_edition_test.rb
+- test/database.yml
+- test/fixtures/abbreviation.rb
+- test/fixtures/abbreviations.yml
+- test/fixtures/alphabet.rb
+- test/fixtures/alphabets.yml
+- test/fixtures/author.rb
+- test/fixtures/authors.yml
+- test/fixtures/countries.yml
+- test/fixtures/country.rb
+- test/fixtures/guide.rb
+- test/fixtures/guides.yml
+- test/fixtures/imprint.rb
+- test/fixtures/imprints.yml
+- test/fixtures/law.rb
+- test/fixtures/laws.yml
+- test/fixtures/map.rb
+- test/fixtures/maps.yml
+- test/fixtures/place.rb
+- test/fixtures/places.yml
+- test/fixtures/retailer.rb
+- test/fixtures/retailers.yml
+- test/schema.rb
+- test/test_helper.rb