acts_as_revisionable 1.0.6 → 1.1.0

data/spec/spec_helper.rb

@@ -1,10 +1,28 @@
 require 'rubygems'
+require 'logger'
+require 'stringio'
 
 if ENV["ACTIVE_RECORD_VERSION"]
   gem 'activerecord', ENV["ACTIVE_RECORD_VERSION"]
 else
   gem 'activerecord'
 end
+require 'active_record'
+require 'active_record/version'
+ActiveRecord::ActiveRecordError
+
+ActiveRecord::Base.logger = Logger.new(StringIO.new)
+puts "Testing with ActiveRecord #{ActiveRecord::VERSION::STRING}"
+
+composite_primary_key_version = nil
+if ActiveRecord::VERSION::MAJOR >= 3
+  composite_primary_key_version = ">=3.0.0"
+else
+  composite_primary_key_version = "~>2.3.5"
+end
+
+gem 'composite_primary_keys', composite_primary_key_version
+require 'composite_primary_keys'
 
 require File.expand_path('../../lib/acts_as_revisionable', __FILE__)
 require 'sqlite3'
@@ -13,7 +31,6 @@ module ActsAsRevisionable
   module Test
     def self.create_database
       ActiveRecord::Base.establish_connection("adapter" => "sqlite3", "database" => ":memory:")
-      ActsAsRevisionable::RevisionRecord.create_table
     end
 
     def self.delete_database

data/spec/version_1_1_upgrade_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe "upgrade to version 1.1" do
+
+  before :each do
+    ActsAsRevisionable::Test.create_database
+  end
+  
+  after :each do
+    ActsAsRevisionable::Test.delete_database
+  end
+  
+  it "should update an older table definition with the latest definition on create_table" do
+    connection = ActsAsRevisionable::RevisionRecord.connection
+    
+    connection.create_table(:revision_records) do |t|
+      t.string :revisionable_type, :null => false, :limit => 100
+      t.integer :revisionable_id, :null => false
+      t.integer :revision, :null => false
+      t.binary :data, :limit => (connection.adapter_name.match(/mysql/i) ? 5.megabytes : nil)
+      t.timestamp :created_at, :null => false
+    end
+    connection.add_index :revision_records, [:revisionable_type, :revisionable_id, :revision], :name => "revisionable", :unique => true
+    
+    ActsAsRevisionable::RevisionRecord.update_version_1_table
+    
+    columns = connection.columns(:revision_records)
+    trash_column = columns.detect{|c| c.name == 'trash'}
+    trash_column.type.should == :boolean
+    trash_column.default.should == false
+    
+    if connection.respond_to?(:index_exists?)
+      connection.index_exists?(:revision_records, [:revisionable_type, :revisionable_id, :revision], :name => "revisionable", :unique => true).should_not
+      connection.index_exists?(:revision_records, :revisionable_id, :name => "revision_record_id").should
+      connection.index_exists?(:revision_records, [:revisionable_type, :created_at, :trash], :name => "revisionable_type_and_created_at").should
+    else
+      STDERR.puts("Could not check if indexes were updated with this version of ActiveRecord")
+    end
+  end
+  
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: acts_as_revisionable
 version: !ruby/object:Gem::Version 
-  hash: 27
+  hash: 19
   prerelease: 
   segments: 
   - 1
+  - 1
   - 0
-  - 6
-  version: 1.0.6
+  version: 1.1.0
 platform: ruby
 authors: 
 - Brian Durand
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-08 00:00:00 -06:00
+date: 2011-06-23 00:00:00 -05:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -26,15 +26,16 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 7
+        hash: 9
         segments: 
         - 2
-        - 2
-        version: "2.2"
+        - 3
+        - 5
+        version: 2.3.5
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: sqlite3
+  name: composite_primary_keys
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
@@ -48,9 +49,23 @@ dependencies:
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: rspec
+  name: sqlite3
   prerelease: false
   requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -62,11 +77,11 @@ dependencies:
         - 0
         version: 2.0.0
   type: :development
-  version_requirements: *id003
+  version_requirements: *id004
 - !ruby/object:Gem::Dependency 
   name: jeweler
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id005 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -76,7 +91,7 @@ dependencies:
         - 0
         version: "0"
   type: :development
-  version_requirements: *id004
+  version_requirements: *id005
 description: ActiveRecord extension that provides revision support so that history can be tracked and changes can be reverted. Emphasis for this plugin versus similar ones is including associations, saving on storage, and extensibility of the model.
 email: brian@embellishedvisions.com
 executables: []
@@ -88,15 +103,16 @@ extra_rdoc_files:
 files: 
 - MIT-LICENSE
 - README.rdoc
+- RELEASES.txt
 - Rakefile
 - VERSION
 - acts_as_revisionable.gemspec
 - lib/acts_as_revisionable.rb
 - lib/acts_as_revisionable/revision_record.rb
 - spec/acts_as_revisionable_spec.rb
-- spec/full_spec.rb
 - spec/revision_record_spec.rb
 - spec/spec_helper.rb
+- spec/version_1_1_upgrade_spec.rb
 has_rdoc: true
 homepage: http://github.com/bdurand/acts_as_revisionable
 licenses: []
@@ -106,6 +122,7 @@ rdoc_options:
 - --charset=UTF-8
 - --main
 - README.rdoc
+- MIT-LICENSE
 require_paths: 
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement 
@@ -129,12 +146,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.4.1
+rubygems_version: 1.5.2
 signing_key: 
 specification_version: 3
 summary: ActiveRecord extension that provides revision support so that history can be tracked and changes can be reverted.
-test_files: 
-- spec/acts_as_revisionable_spec.rb
-- spec/full_spec.rb
-- spec/revision_record_spec.rb
-- spec/spec_helper.rb
+test_files: []
+

data/spec/full_spec.rb

@@ -1,449 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
-
-describe "ActsAsRevisionable Full Test" do
-  
-  before(:all) do
-    ActsAsRevisionable::Test.create_database
-    
-    ActiveRecord::Base.store_full_sti_class = true
-  
-    class RevisionableTestSubThing < ActiveRecord::Base
-      connection.create_table(:revisionable_test_sub_things) do |t|
-        t.column :name, :string
-        t.column :revisionable_test_many_thing_id, :integer
-      end unless table_exists?
-    end
-
-    class RevisionableTestManyThing < ActiveRecord::Base
-      connection.create_table(:revisionable_test_many_things) do |t|
-        t.column :name, :string
-        t.column :revisionable_test_model_id, :integer
-      end unless table_exists?
-    
-      has_many :sub_things, :class_name => 'RevisionableTestSubThing'
-    end
-
-    class RevisionableTestManyOtherThing < ActiveRecord::Base
-      connection.create_table(:revisionable_test_many_other_things) do |t|
-        t.column :name, :string
-        t.column :revisionable_test_model_id, :integer
-      end unless table_exists?
-    end
-
-    class RevisionableTestOneThing < ActiveRecord::Base
-      connection.create_table(:revisionable_test_one_things) do |t|
-        t.column :name, :string
-        t.column :revisionable_test_model_id, :integer
-      end unless table_exists?
-    end
-
-    class NonRevisionableTestModel < ActiveRecord::Base
-      connection.create_table(:non_revisionable_test_models) do |t|
-        t.column :name, :string
-      end unless table_exists?
-    end
-    
-    class NonRevisionableTestModelsRevisionableTestModel < ActiveRecord::Base
-      connection.create_table(:non_revisionable_test_models_revisionable_test_models, :id => false) do |t|
-        t.column :non_revisionable_test_model_id, :integer
-        t.column :revisionable_test_model_id, :integer
-      end unless table_exists?
-    end
-
-    class RevisionableTestModel < ActiveRecord::Base
-      connection.create_table(:revisionable_test_models) do |t|
-        t.column :name, :string
-        t.column :secret, :integer
-      end unless table_exists?
-    
-      has_many :many_things, :class_name => 'RevisionableTestManyThing', :dependent => :destroy
-      has_many :many_other_things, :class_name => 'RevisionableTestManyOtherThing', :dependent => :destroy
-      has_one :one_thing, :class_name => 'RevisionableTestOneThing'
-      has_and_belongs_to_many :non_revisionable_test_models
-  
-      attr_protected :secret
-      
-      acts_as_revisionable :limit => 3, :associations => [:one_thing, :non_revisionable_test_models, {:many_things => :sub_things}]
-      
-      def set_secret (val)
-        self.secret = val
-      end
-      
-      private
-      
-      def secret= (val)
-        self[:secret] = val
-      end
-    end
-
-    module ActsAsRevisionable
-      class RevisionableNamespaceModel < ActiveRecord::Base
-        connection.create_table(:revisionable_namespace_models) do |t|
-          t.column :name, :string
-          t.column :type_name, :string
-        end unless table_exists?
-        
-        set_inheritance_column :type_name
-        acts_as_revisionable :dependent => :keep, :encoding => :xml
-        self.store_full_sti_class = false
-      end
-      
-      class RevisionableSubclassModel < RevisionableNamespaceModel
-      end
-    end
-  end
-  
-  after :all do
-    ActsAsRevisionable::Test.delete_database
-  end
-  
-  before :each do
-    RevisionableTestModel.delete_all
-    RevisionableTestManyThing.delete_all
-    RevisionableTestManyOtherThing.delete_all
-    RevisionableTestSubThing.delete_all
-    RevisionableTestOneThing.delete_all
-    NonRevisionableTestModelsRevisionableTestModel.delete_all
-    NonRevisionableTestModel.delete_all
-    ActsAsRevisionable::RevisionRecord.delete_all
-    ActsAsRevisionable::RevisionableNamespaceModel.delete_all
-  end
-  
-  it "should only store revisions in a store revision block if :on_update is not true" do
-    model = RevisionableTestModel.new(:name => 'test')
-    model.set_secret(1234)
-    model.save!
-    ActsAsRevisionable::RevisionRecord.count.should == 0
-    model.name = 'new_name'
-    model.save!
-    ActsAsRevisionable::RevisionRecord.count.should == 0
-  end
-  
-  it "should not save a revision if an update raises an exception" do
-    model = RevisionableTestModel.new(:name => 'test')
-    model.store_revision do
-      model.save!
-    end
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 0
-    
-    model.should_receive(:update).and_raise("update failed")
-    model.name = 'new_name'
-    begin
-      model.store_revision do
-        ActsAsRevisionable::RevisionRecord.count.should == 1
-        model.save
-      end
-    rescue
-    end
-    ActsAsRevisionable::RevisionRecord.count.should == 0
-  end
-  
-  it "should not save a revision if an update fails with errors" do
-    model = RevisionableTestModel.new(:name => 'test')
-    model.store_revision do
-      model.save!
-    end
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 0
-    
-    model.name = 'new_name'
-    model.store_revision do
-      ActsAsRevisionable::RevisionRecord.count.should == 1
-      model.save!
-      model.errors.add(:name, "isn't right")
-    end
-    ActsAsRevisionable::RevisionRecord.count.should == 0
-  end
-  
-  it "should restore a record without associations" do
-    model = RevisionableTestModel.new(:name => 'test')
-    model.set_secret(1234)
-    model.store_revision do
-      model.save!
-    end
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 0
-    
-    model.name = 'new_name'
-    model.set_secret(5678)
-    model.store_revision do
-      model.save!
-    end
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 1
-    model.name.should == 'new_name'
-    model.secret.should == 5678
-    
-    restored = model.restore_revision(1)
-    restored.name.should == 'test'
-    restored.secret.should == 1234
-    restored.id.should == model.id
-    
-    restored.store_revision do
-      restored.save!
-    end
-    RevisionableTestModel.count.should == 1
-    ActsAsRevisionable::RevisionRecord.count.should == 2
-    restored_model = RevisionableTestModel.find(model.id)
-    restored_model.name.should == restored.name
-    restored_model.secret.should == restored.secret
-  end
-  
-  it "should restore a record with has_many associations" do
-    many_thing_1 = RevisionableTestManyThing.new(:name => 'many_thing_1')
-    many_thing_1.sub_things.build(:name => 'sub_thing_1')
-    many_thing_1.sub_things.build(:name => 'sub_thing_2')
-    
-    model = RevisionableTestModel.new(:name => 'test')
-    model.many_things << many_thing_1
-    model.many_things.build(:name => 'many_thing_2')
-    model.many_other_things.build(:name => 'many_other_thing_1')
-    model.many_other_things.build(:name => 'many_other_thing_2')
-    model.save!
-    model.reload
-    RevisionableTestManyThing.count.should == 2
-    RevisionableTestSubThing.count.should == 2
-    RevisionableTestManyOtherThing.count.should == 2
-    ActsAsRevisionable::RevisionRecord.count.should == 0
-    
-    model.store_revision do
-      model.name = 'new_name'
-      many_thing_1 = model.many_things.detect{|t| t.name == 'many_thing_1'}
-      many_thing_1.name = 'new_many_thing_1'
-      sub_thing_1 = many_thing_1.sub_things.detect{|t| t.name == 'sub_thing_1'}
-      sub_thing_1.name = 'new_sub_thing_1'
-      sub_thing_2 = many_thing_1.sub_things.detect{|t| t.name == 'sub_thing_2'}
-      many_thing_1.sub_things.build(:name => 'sub_thing_3')
-      many_thing_1.sub_things.delete(sub_thing_2)
-      many_thing_2 = model.many_things.detect{|t| t.name == 'many_thing_2'}
-      model.many_things.delete(many_thing_2)
-      model.many_things.build(:name => 'many_thing_3')
-      many_other_thing_1 = model.many_other_things.detect{|t| t.name == 'many_other_thing_1'}
-      many_other_thing_1.name = 'new_many_other_thing_1'
-      many_other_thing_2 = model.many_other_things.detect{|t| t.name == 'many_other_thing_2'}
-      model.many_other_things.delete(many_other_thing_2)
-      model.many_other_things.build(:name => 'many_other_thing_3')
-      model.save!
-      many_thing_1.save!
-      sub_thing_1.save!
-      many_other_thing_1.save!
-    end
-    
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 1
-    RevisionableTestManyThing.count.should == 2
-    RevisionableTestSubThing.count.should == 3
-    RevisionableTestManyOtherThing.count.should == 2
-    model.name.should == 'new_name'
-    model.many_things.collect{|t| t.name}.sort.should == ['many_thing_3', 'new_many_thing_1']
-    model.many_things.detect{|t| t.name == 'new_many_thing_1'}.sub_things.collect{|t| t.name}.sort.should == ['new_sub_thing_1', 'sub_thing_3']
-    model.many_other_things.collect{|t| t.name}.sort.should == ['many_other_thing_3', 'new_many_other_thing_1']
-    
-    # restore to memory
-    restored = model.restore_revision(1)
-    restored.name.should == 'test'
-    restored.id.should == model.id
-    restored.many_things.collect{|t| t.name}.sort.should == ['many_thing_1', 'many_thing_2']
-    restored.many_things.detect{|t| t.name == 'many_thing_1'}.sub_things.collect{|t| t.name}.sort.should == ['sub_thing_1', 'sub_thing_2']
-    restored.many_other_things.collect{|t| t.name}.sort.should == ['many_other_thing_3', 'new_many_other_thing_1']
-    restored.valid?.should == true
-    
-    # make the restore to memory didn't affect the database
-    model.reload
-    model.name.should == 'new_name'
-    model.many_things.collect{|t| t.name}.sort.should == ['many_thing_3', 'new_many_thing_1']
-    model.many_things.detect{|t| t.name == 'new_many_thing_1'}.sub_things.collect{|t| t.name}.sort.should == ['new_sub_thing_1', 'sub_thing_3']
-    model.many_other_things.collect{|t| t.name}.sort.should == ['many_other_thing_3', 'new_many_other_thing_1']
-    
-    model.restore_revision!(1)
-    RevisionableTestModel.count.should == 1
-    RevisionableTestManyThing.count.should == 2
-    RevisionableTestSubThing.count.should == 3
-    RevisionableTestManyOtherThing.count.should == 2
-    ActsAsRevisionable::RevisionRecord.count.should == 2
-    restored_model = RevisionableTestModel.find(model.id)
-    restored_model.name.should == 'test'
-    restored.many_things.collect{|t| t.name}.sort.should == ['many_thing_1', 'many_thing_2']
-    restored.many_things.detect{|t| t.name == 'many_thing_1'}.sub_things.collect{|t| t.name}.sort.should == ['sub_thing_1', 'sub_thing_2']
-    restored.many_things.detect{|t| t.name == 'many_thing_2'}.sub_things.collect{|t| t.name}.sort.should == []
-    restored.many_other_things.collect{|t| t.name}.sort.should == ['many_other_thing_3', 'new_many_other_thing_1']
-  end
-  
-  it "should restore a record with has_one associations" do
-    model = RevisionableTestModel.new(:name => 'test')
-    model.build_one_thing(:name => 'other')
-    model.store_revision do
-      model.save!
-    end
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 0
-    RevisionableTestOneThing.count.should == 1
-    
-    model.name = 'new_name'
-    model.one_thing.name = 'new_other'
-    model.store_revision do
-      model.one_thing.save!
-      model.save!
-    end
-    
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 1
-    model.name.should == 'new_name'
-    model.one_thing.name.should == 'new_other'
-    
-    # restore to memory
-    restored = model.restore_revision(1)
-    restored.name.should == 'test'
-    restored.one_thing.name.should == 'other'
-    restored.one_thing.id.should == model.one_thing.id
-    
-    # make sure restore to memory didn't affect the database
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 1
-    model.name.should == 'new_name'
-    model.one_thing.name.should == 'new_other'
-    
-    model.restore_revision!(1)
-    RevisionableTestModel.count.should == 1
-    RevisionableTestOneThing.count.should == 1
-    ActsAsRevisionable::RevisionRecord.count.should == 2
-    restored_model = RevisionableTestModel.find(model.id)
-    restored_model.name.should == 'test'
-    restored_model.one_thing.name.should == 'other'
-    restored_model.one_thing.id.should == model.one_thing.id
-  end
-  
-  it "should restore a record with has_and_belongs_to_many associations" do
-    other_1 = NonRevisionableTestModel.create(:name => 'one')
-    other_2 = NonRevisionableTestModel.create(:name => 'two')
-    model = RevisionableTestModel.new(:name => 'test')
-    model.non_revisionable_test_models = [other_1, other_2]
-    model.store_revision do
-      model.save!
-    end
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 0
-    NonRevisionableTestModel.count.should == 2
-    
-    model.name = 'new_name'
-    other_1.name = '111'
-    other_3 = NonRevisionableTestModel.create(:name => '333')
-    model.store_revision do
-      model.non_revisionable_test_models = [other_1, other_3]
-      other_1.save!
-      model.save!
-    end
-    
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 1
-    NonRevisionableTestModel.count.should == 3
-    model.name.should == 'new_name'
-    model.non_revisionable_test_models.collect{|r| r.name}.sort.should == ['111', '333']
-    
-    # restore to memory
-    restored = model.restore_revision(1)
-    restored.name.should == 'test'
-    restored.non_revisionable_test_models.collect{|r| r.name}.sort.should == ['111', 'two']
-    
-    # make sure the restore to memory didn't affect the database
-    model.reload
-    model.name.should == 'new_name'
-    model.non_revisionable_test_models.collect{|r| r.name}.sort.should == ['111', '333']
-    
-    model.restore_revision!(1)
-    NonRevisionableTestModelsRevisionableTestModel.count.should == 2
-    RevisionableTestModel.count.should == 1
-    NonRevisionableTestModel.count.should == 3
-    ActsAsRevisionable::RevisionRecord.count.should == 2
-    restored_model = RevisionableTestModel.find(model.id)
-    restored_model.name.should == 'test'
-    restored_model.non_revisionable_test_models.collect{|r| r.name}.sort.should == ['111', 'two']
-  end
-  
-  it "should handle namespaces and single table inheritance" do
-    model = ActsAsRevisionable::RevisionableNamespaceModel.new(:name => 'test')
-    model.store_revision do
-      model.save!
-    end
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 0
-    
-    model.name = 'new_name'
-    model.store_revision do
-      model.save!
-    end
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 1
-    model.name.should == 'new_name'
-    
-    restored = model.restore_revision(1)
-    restored.class.should == ActsAsRevisionable::RevisionableNamespaceModel
-    restored.name.should == 'test'
-    restored.id.should == model.id
-  end
-  
-  it "should handle single table inheritance" do
-    model = ActsAsRevisionable::RevisionableSubclassModel.new(:name => 'test')
-    model.store_revision do
-      model.save!
-    end
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 0
-    
-    model.name = 'new_name'
-    model.store_revision do
-      model.save!
-    end
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 1
-    model.name.should == 'new_name'
-    
-    restored = model.restore_revision(1)
-    restored.class.should == ActsAsRevisionable::RevisionableSubclassModel
-    restored.name.should == 'test'
-    restored.id.should == model.id
-    restored.type_name.should == 'RevisionableSubclassModel'
-  end
-  
-  it "should destroy revisions if :dependent => :keep was not specified" do
-    model = RevisionableTestModel.new(:name => 'test')
-    model.store_revision do
-      model.save!
-    end
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 0
-    
-    model.name = 'new_name'
-    model.store_revision do
-      model.save!
-    end
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 1
-    model.name.should == 'new_name'
-    
-    model.destroy
-    ActsAsRevisionable::RevisionRecord.count.should == 0
-  end
-  
-  it "should not destroy revisions if :dependent => :keep was specified" do
-    model = ActsAsRevisionable::RevisionableSubclassModel.new(:name => 'test')
-    model.store_revision do
-      model.save!
-    end
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 0
-    
-    model.name = 'new_name'
-    model.store_revision do
-      model.save!
-    end
-    model.reload
-    ActsAsRevisionable::RevisionRecord.count.should == 1
-    model.name.should == 'new_name'
-    
-    model.destroy
-    ActsAsRevisionable::RevisionRecord.count.should == 1
-  end
-  
-end