rtiss_acts_as_versioned 0.7.9 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a52b967ef4cb3fd70eda63abb22684b5ee4d5b1
-  data.tar.gz: b057e9ebe4156925141231be0e28203b0a56e03c
+  metadata.gz: a47925d46be533c4270653aa1c6ecd3bdec9a8d5
+  data.tar.gz: 2d1c25a86d66ab51f3c747f26abc34818e8a4b53
 SHA512:
-  metadata.gz: cec76f055810b23b62087ccd0bb02228f485f1b61df23d8582fe09eeb6004bb928108d33872a9f6c49882c37dbf819bf00795639944774e27238551d30902e15
-  data.tar.gz: de50c719b3f639119dbe6fca26f0ef58940957f3dd80958db40682f51680ccc1f2639d3533c30ec63dad31130be93a8c8b474e1900e3fe431158dfdc8bafaa6c
+  metadata.gz: a117151d322b33a6a87eec2931bb4f6d3290c84d9ffcc18b3e248188e745fcd7a81557893c585e2d061b861a4893b57af23979120a9e6637b3b5512a1528e400
+  data.tar.gz: 7bdca076be71230b7e08e4daf4527177829efce40f884265e4fbfeed4f17f2111f30fe1ed326d61e9457f3891ba798f4d22f6f7973b35d44963b403cdd197ee4

data/README

@@ -2,12 +2,6 @@
 
 This library adds simple versioning to an ActiveRecord module.  ActiveRecord is required.
 
-This is the patched version for rtiss.
-
-Versions 0.6.x (rails2 branch) are for rails 2.x
-Versions 0.7.x (rails3 branch) are for rails 3.x
-Versions 0.8.x (master branch) are for rails 4.x
-
 == Resources
 
 Install
@@ -27,10 +21,4 @@ Subversion
 * http://svn.github.com/technoweenie/acts_as_versioned.git
 
 Special thanks to Dreamer on ##rubyonrails for help in early testing.  His ServerSideWiki (http://serversidewiki.com) 
-was the first project to use acts_as_versioned <em>in the wild</em>.
-
-== Publishing a new release
-
-* increase the VERSION in rtiss_acts_as_versioned.rb
-* run: bundle exec rake test
-* run: bundle exec rake release
+was the first project to use acts_as_versioned <em>in the wild</em>.

data/Rakefile

@@ -73,6 +73,14 @@ task :console do
   sh "irb -rubygems -r ./lib//#{name}.rb"
 end
 
+#############################################################################
+#
+# Custom tasks (add your own tasks here)
+#
+#############################################################################
+
+
+
 #############################################################################
 #
 # Packaging tasks
@@ -80,11 +88,14 @@ end
 #############################################################################
 
 task :release => :build do
+  unless `git branch` =~ /^\* master$/
+    puts "You must be on the master branch to release!"
+    exit!
+  end
   sh "git commit --allow-empty -a -m 'Release #{version}'"
-  sh "git tag #{version}"                   # create new release tag
-  sh "git push origin rails3"               # push current branch
-  sh "git push origin #{version}"           # push the new release tag
-  sh "gem push pkg/#{name}-#{version}.gem"  # push the gem to RubyGems.org
+  sh "git tag #{version}"
+  sh "git push origin master --tags"
+  sh "gem push pkg/#{name}-#{version}.gem"
 end
 
 task :build => :gemspec do

data/lib/rtiss_acts_as_versioned.rb

@@ -20,7 +20,7 @@
 # OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 
-VERSION = '0.7.9'
+VERSION = '0.8.0'
 
 module ActiveRecord #:nodoc:
   module Acts #:nodoc:
@@ -173,7 +173,7 @@ module ActiveRecord #:nodoc:
 
           cattr_accessor :versioned_class_name, :versioned_foreign_key, :versioned_table_name, :versioned_inheritance_column, 
             :version_column, :max_version_limit, :track_altered_attributes, :version_condition, :version_sequence_name, :non_versioned_columns,
-            :version_association_options, :version_if_changed, :deleted_in_original_table_flag, :record_restored_column
+            :version_association_options, :version_if_changed, :deleted_in_original_table_flag, :record_restored_flag
 
           self.versioned_class_name         = options[:class_name]  || "Version"
           self.versioned_foreign_key        = options[:foreign_key] || self.to_s.foreign_key
@@ -182,14 +182,11 @@ module ActiveRecord #:nodoc:
           self.versioned_inheritance_column = options[:inheritance_column] || "versioned_#{inheritance_column}"
           self.version_column               = options[:version_column]     || 'version'
           self.deleted_in_original_table_flag = options[:deleted_in_original_table_flag]     || 'deleted_in_original_table'
-          self.record_restored_column       = options[:record_restored_column]     || 'record_restored'
+          self.record_restored_flag = options[:record_restored_flag]     || 'record_restored'
           self.version_sequence_name        = options[:sequence_name]
           self.max_version_limit            = options[:limit].to_i
           self.version_condition            = options[:if] || true
           self.non_versioned_columns        = [self.primary_key, inheritance_column, self.version_column, 'lock_version', versioned_inheritance_column] + options[:non_versioned_columns].to_a.map(&:to_s)
-          if options[:association_options].is_a?(Hash) && options[:association_options][:dependent] == :nullify
-            raise "Illegal option :dependent => :nullify - this would produce orphans in version model"
-          end
           self.version_association_options  = {
                                                 :class_name  => "#{self.to_s}::#{versioned_class_name}",
                                                 :foreign_key => versioned_foreign_key
@@ -204,7 +201,7 @@ module ActiveRecord #:nodoc:
             options[:extend] = self.const_get(extension_module_name)
           end
 
-          class_eval <<-CLASS_METHODS
+          class_eval <<-CLASS_METHODS, __FILE__, __LINE__ + 1
             has_many :versions, version_association_options do
               # finds earliest version of this record
               def earliest
@@ -234,7 +231,6 @@ module ActiveRecord #:nodoc:
           const_set(versioned_class_name, Class.new(ActiveRecord::Base)).class_eval do
             def self.reloadable? ; false ; end
             # find first version before the given version
-            # TODO: replace "version" in selects with version_column, use select-method instead of find
             def self.before(version)
               find :first, :order => 'version desc',
                 :conditions => ["#{original_class.versioned_foreign_key} = ? and version < ?", version.send(original_class.versioned_foreign_key), version.version]
@@ -267,7 +263,7 @@ module ActiveRecord #:nodoc:
               version_hash = self.attributes
               version_hash.delete "id"
               version_hash.delete self.original_class.deleted_in_original_table_flag.to_s
-              version_hash.delete self.original_class.record_restored_column.to_s
+              version_hash.delete self.original_class.record_restored_flag.to_s
               version_hash.delete self.original_class.versioned_foreign_key.to_s
 
               restored_record = self.original_class.new(version_hash)
@@ -275,26 +271,18 @@ module ActiveRecord #:nodoc:
               if restored_record.respond_to? :updated_at=
                 restored_record.updated_at = Time.now
               end
-              # DON'T EVEN THINK ABOUT CALCULATING THE VERSION NUMBER USING THE VERSIONS ASSOCIATION HERE:
-              # There is a problem in ActiveRecord. An association Relation will be converted to an Array internally, when the SQL-select is
-              # executed.
-              # Some ActiveRecord-Methods (for example #ActiveRecord::Base::AutosaveAssociation#save_collection_association) try to use ActiveRecord methods
-              # with these Relations, and if these Relations have been converted to Arrays, these calls fail with an Exception
-              new_version_number = self.class.where(self.original_class.versioned_foreign_key => id).order('id desc').first.send(restored_record.version_column).to_i + 1
-              restored_record.send("#{restored_record.version_column}=", new_version_number)
               unless restored_record.save_without_revision(perform_validation)
                 raise RuntimeError.new("Couldn't restore the record, id = #{id} class = #{self.class.name}")
               end
-              restored_record.save_version(true, false, self.send(self.original_class.version_column))
-            end
-
-            def record_restored?
-              self.read_attribute(self.original_class.record_restored_column) != nil
-            end
-            alias :record_restored :record_restored?
 
-            def record_restored_from_version
-              self.read_attribute(self.original_class.record_restored_column)
+              new_version = clone
+              new_version.version += 1
+              new_version.send("#{self.original_class.deleted_in_original_table_flag}=", false)
+              new_version.send("#{self.original_class.record_restored_flag}=", true)
+              if new_version.respond_to? :updated_at=
+                new_version.updated_at = Time.now
+              end
+              new_version.save!
             end
 
             def original_record_exists?
@@ -319,15 +307,15 @@ module ActiveRecord #:nodoc:
         end
 
         # Saves a version of the model in the versioned table.  This is called in the after_save callback by default
-        def save_version(save_this=false, deleted_flag=false, restored_from_version=nil)
-          if @saving_version || save_this
+        def save_version
+          if @saving_version
             @saving_version = nil
             rev = self.class.versioned_class.new
             clone_versioned_model(self, rev)
             rev.send("#{self.class.version_column}=", send(self.class.version_column))
             rev.send("#{self.class.versioned_foreign_key}=", id)
-            rev.send("#{self.class.deleted_in_original_table_flag}=", deleted_flag)
-            rev.send("#{self.class.record_restored_column}=", restored_from_version)
+            rev.send("#{self.class.deleted_in_original_table_flag}=", false)
+            rev.send("#{self.class.record_restored_flag}=", false)
             if rev.respond_to? :updated_at=
               rev.updated_at = Time.now
             end
@@ -343,7 +331,7 @@ module ActiveRecord #:nodoc:
           rev.send("#{self.class.version_column}=", highest_version+1)
           rev.send("#{self.class.versioned_foreign_key}=", id)
           rev.send("#{self.class.deleted_in_original_table_flag}=", true)
-          rev.send("#{self.class.record_restored_column}=", nil)
+          rev.send("#{self.class.record_restored_flag}=", false)
           if rev.respond_to? :updated_at=
             rev.updated_at = Time.now
           end
@@ -363,11 +351,9 @@ module ActiveRecord #:nodoc:
         # Reverts a model to a given version.  Takes either a version number or an instance of the versioned model
         def revert_to(version)
           if version.is_a?(self.class.versioned_class)
-            @reverted_from = version.send(self.class.version_column)
             return false unless version.send(self.class.versioned_foreign_key) == id and !version.new_record?
           else
-            @reverted_from = version
-            return false unless version = versions.where(self.class.version_column => version).first
+            return false unless version = versions.send("find_by_#{self.class.version_column}", version)
           end
           self.clone_versioned_model(version, self)
           send("#{self.class.version_column}=", version.send(self.class.version_column))
@@ -377,13 +363,7 @@ module ActiveRecord #:nodoc:
         # Reverts a model to a given version and saves the model.
         # Takes either a version number or an instance of the versioned model
         def revert_to!(version)
-          if revert_to(version)
-            set_new_version
-            save_without_revision
-            save_version(true, false, @reverted_from)
-          else
-            false
-          end
+          revert_to(version) ? save_without_revision : false
         end
 
         # Temporarily turns off Optimistic Locking while saving.  Used when reverting so that a new version is not created.
@@ -486,7 +466,7 @@ module ActiveRecord #:nodoc:
         def find_newest_version
           return nil if self.id.nil?
 
-          self.class.versioned_class.where("#{self.class.versioned_foreign_key} = #{self.id}").order("version DESC").first
+          self.class.versioned_class.find(:first, :conditions => "#{self.class.versioned_foreign_key} = #{self.id}", :order => "version DESC")
         end
 
         def highest_version
@@ -501,22 +481,22 @@ module ActiveRecord #:nodoc:
         def find_version(version)
           return nil if self.id.nil?
 
-          ret = self.class.versioned_class.where("#{self.class.versioned_foreign_key} = #{self.id} and #{self.class.version_column}=#{version}").first
+          ret = self.class.versioned_class.find(:first, :conditions => "#{self.class.versioned_foreign_key} = #{self.id} and version=#{version}") # TODO: version column
           raise "find_version: version #{version} not found in database" unless ret
           ret
         end
 
         protected
-        # sets the new version before saving
-        def set_new_version
-          @saving_version = new_record? || save_version?
-          self.send("#{self.class.version_column}=", next_version) if new_record? || save_version?
-        end
+          # sets the new version before saving, unless you're using optimistic locking.  In that case, let it take care of the version.
+          def set_new_version
+            @saving_version = new_record? || save_version?
+            self.send("#{self.class.version_column}=", next_version) if new_record? || (!locking_enabled? && save_version?)
+          end
 
-        # Gets the next available version for the current record, or 1 for a new record
-        def next_version
-          (new_record? ? 0 : versions.calculate(:maximum, version_column).to_i) + 1
-        end
+          # Gets the next available version for the current record, or 1 for a new record
+          def next_version
+            (new_record? ? 0 : versions.calculate(:maximum, version_column).to_i) + 1
+          end
 
         module ClassMethods
           # Returns an array of columns that are versioned.  See non_versioned_columns
@@ -543,7 +523,7 @@ module ActiveRecord #:nodoc:
               t.column versioned_foreign_key, :integer
               t.column version_column, :integer
               t.column deleted_in_original_table_flag, :boolean, :default => false
-              t.column record_restored_column, :integer, :default => nil
+              t.column record_restored_flag, :boolean, :default => false
             end
 
             self.versioned_columns.each do |col| 

data/rtiss_acts_as_versioned.gemspec

@@ -12,8 +12,8 @@ Gem::Specification.new do |s|
   ## If your rubyforge_project name is different, then edit it and comment out
   ## the sub! line in the Rakefile
   s.name              = 'rtiss_acts_as_versioned'
-  s.version           = '0.7.9'
-  s.date              = '2014-11-18'
+  s.version           = '0.8.0'
+  s.date              = '2014-10-30'
   s.rubyforge_project = 'rtiss_acts_as_versioned'
   s.summary     = "Add simple versioning to ActiveRecord models (TISS version)."
   s.description = "Add simple versioning to ActiveRecord models (TISS version).

data/test/fixtures/locked_pages.yml

@@ -1,12 +1,10 @@
 welcome:
   id: 1
   title: Welcome to the weblog
-  version: 24
-  lock_version: 1
+  lock_version: 24
   type: LockedPage
 thinking:
   id: 2
   title: So I was thinking
-  version: 24
-  lock_version: 1
+  lock_version: 24
   type: SpecialLockedPage

data/test/fixtures/locked_pages_revisions.yml

@@ -2,26 +2,26 @@ welcome_1:
   id: 1
   page_id: 1
   title: Welcome to the weblg
-  version: 23
+  lock_version: 23
   version_type: LockedPage
 
 welcome_2:
   id: 2
   page_id: 1
   title: Welcome to the weblog
-  version: 24
+  lock_version: 24
   version_type: LockedPage
 
 thinking_1:
   id: 3
   page_id: 2
   title: So I was thinking!!!
-  version: 23
+  lock_version: 23
   version_type: SpecialLockedPage
 
 thinking_2:
   id: 4
   page_id: 2
   title: So I was thinking
-  version: 24
+  lock_version: 24
   version_type: SpecialLockedPage

data/test/fixtures/page.rb

@@ -29,6 +29,7 @@ class LockedPage < ActiveRecord::Base
     :foreign_key        => :page_id, 
     :table_name         => :locked_pages_revisions, 
     :class_name         => 'LockedPageRevision',
+    :version_column     => :lock_version,
     :limit              => 2,
     :if_changed         => :title,
     :extend             => LockedPageExtension

data/test/fixtures/widget.rb

@@ -1,6 +1,6 @@
 class Widget < ActiveRecord::Base
   acts_as_versioned :sequence_name => 'widgets_seq', :association_options => {
-    :order => 'version desc' # Don't nullify the foreign key column when deleting the original record! :dependent => :nullify option removed
+    :dependent => :nullify, :order => 'version desc'
   }
   non_versioned_columns << 'foo'
 end

data/test/schema.rb

@@ -19,7 +19,7 @@ ActiveRecord::Schema.define(:version => 0) do
     t.column :author_id, :integer
     t.column :revisor_id, :integer
     t.column :deleted_in_original_table, :boolean
-    t.column :record_restored, :integer, :precision => 38,  :scale => 0, :default => nil
+    t.column :record_restored, :boolean
   end
   
   add_index :pages_h, [:page_id, :version], :unique => true
@@ -31,7 +31,6 @@ ActiveRecord::Schema.define(:version => 0) do
   
   create_table :locked_pages, :force => true do |t|
     t.column :lock_version, :integer
-    t.column :version, :integer
     t.column :title, :string, :limit => 255
     t.column :body, :text
     t.column :type, :string, :limit => 255
@@ -39,17 +38,16 @@ ActiveRecord::Schema.define(:version => 0) do
 
   create_table :locked_pages_revisions, :force => true do |t|
     t.column :page_id, :integer
-    t.column :version, :integer
-    #t.column :lock_version, :integer
+    t.column :lock_version, :integer
     t.column :title, :string, :limit => 255
     t.column :body, :text
     t.column :version_type, :string, :limit => 255
     t.column :updated_at, :datetime
     t.column :deleted_in_original_table, :boolean
-    t.column :record_restored, :integer, :precision => 38,  :scale => 0, :default => nil
+    t.column :record_restored, :boolean
   end
   
-  add_index :locked_pages_revisions, [:page_id, :version], :unique => true
+  add_index :locked_pages_revisions, [:page_id, :lock_version], :unique => true
 
   create_table :widgets, :force => true do |t|
     t.column :name, :string, :limit => 50
@@ -64,7 +62,7 @@ ActiveRecord::Schema.define(:version => 0) do
     t.column :version, :integer
     t.column :updated_at, :datetime
     t.column :deleted_in_original_table, :boolean
-    t.column :record_restored, :integer, :precision => 38,  :scale => 0, :default => nil
+    t.column :record_restored, :boolean
   end
   
   add_index :widgets_h, [:widget_id, :version], :unique => true
@@ -85,7 +83,7 @@ ActiveRecord::Schema.define(:version => 0) do
     t.column :doesnt_trigger_version,:string
     t.column :version, :integer
     t.column :deleted_in_original_table, :boolean
-    t.column :record_restored, :integer, :precision => 38,  :scale => 0, :default => nil
+    t.column :record_restored, :boolean
   end
   
   add_index :landmark_h, [:landmark_id, :version], :unique => true
@@ -113,7 +111,7 @@ ActiveRecord::Schema.define(:version => 0) do
     t.string   "name",                      :limit => 50
     t.string   "beschreibung",              :limit => 250
     t.boolean  "deleted_in_original_table",                 :precision => 1,  :scale => 0
-    t.integer  "record_restored",                           :precision => 38,  :scale => 0, :default => nil
+    t.boolean  "record_restored",                 :precision => 1,  :scale => 0
     t.integer  "parent_id",                                 :precision => 38, :scale => 0
     t.string   "beschreibung_intern",       :limit => 4000
     t.string   "geltungsbereich",           :limit => 1000
@@ -146,7 +144,7 @@ ActiveRecord::Schema.define(:version => 0) do
     t.string   "name",                      :limit => 50
     t.string   "beschreibung",              :limit => 250
     t.boolean  "deleted_in_original_table",                 :precision => 1,  :scale => 0
-    t.integer  "record_restored",                           :precision => 38,  :scale => 0, :default => nil
+    t.boolean  "record_restored",                 :precision => 1,  :scale => 0
     t.integer  "parent_id",                                 :precision => 38, :scale => 0
     t.string   "beschreibung_intern",       :limit => 4000
     t.string   "geltungsbereich",           :limit => 1000

data/test/tiss_test.rb

@@ -106,63 +106,23 @@ class TissTest < ActiveSupport::TestCase
     oid = o.id
     v = o.find_version(1)
     assert v!=nil
-
+    
     assert_raises(RuntimeError) { v.restore }
     assert !v.deleted_in_original_table
     assert !v.record_restored, "Record_restored shows that the record was undeleted (should be false) for a newly created record"
 
-    old_version = o.version
     o.destroy
     v = o.find_newest_version
-    first_delete_version = v.version
-    assert v.deleted_in_original_table, "Deleted-Flag in versioned record is not set"
-    assert_equal old_version + 1, v.version, "Destroy did not increment version number in history record"
+    assert v.deleted_in_original_table
 
     v.restore
-    restored_version = v.version
     assert !v.record_restored, "Record_restored shows that the record was undeleted (should be false) for the restored version record (but should be in the newly created record)"
     o = Rolle.find oid
+    assert v.version == o.version, "Version field not restored correctly"
+
     v = o.find_newest_version
-    v_old = v
-    assert_equal v.version, o.version
-    assert_equal old_version + 2, v.version, "Version field not restored correctly"
     assert !v.deleted_in_original_table, "Deleted_in_original_table doesn't show that the record was undeleted (should be false)"
     assert v.record_restored, "Record_restored doesn't show that the record was undeleted (should be true) for the version record created upon restore"
-    assert_equal restored_version, v.record_restored_from_version
-
-    o.name = 'kaputt'
-    assert o.save
-    o.destroy
-    v = o.find_newest_version
-    v.restore
-    o = Rolle.find oid
-    assert_equal v.version + 1, o.version
-    assert_equal 'kaputt', o.name
-    assert_equal v.version, o.find_newest_version.record_restored_from_version
-    o.destroy
-    v_old.restore
-    o = Rolle.find oid
-    assert_equal 'lebt', o.name
-    assert_equal v_old.version, o.find_newest_version.record_restored_from_version
-  end
-
-  def test_restore_and_destroy_with_revision_on_every_change
-    r = Rolle.new(:name => 'karin')
-    assert r.save
-    r.name = 'zak'
-    assert r.save
-    assert_equal 2, Rolle::Version.count
-    r.destroy
-    assert_equal 0, Rolle.count
-    assert_equal 3, Rolle::Version.count
-    assert version = r.find_version(3)
-    assert version.deleted_in_original_table?
-    assert version = r.find_version(2)
-    version.restore
-    assert r = Rolle.first
-    assert r.find_newest_version.record_restored?
-    assert_equal 4, Rolle::Version.count
-    assert_equal 4, r.version
   end
 
   def test_original_record_exists
@@ -233,8 +193,7 @@ class TissTest < ActiveSupport::TestCase
     assert r.save
     r.name = 'zak'
     assert r.save
-    r.reload
-    assert_equal 2, r.versions.size
+    assert_equal 2, r.versions.size 
     assert_equal 2, r.versions.count
   end
 
@@ -246,9 +205,9 @@ class TissTest < ActiveSupport::TestCase
     
     r = Rolle.new(:name => 'karin')
     assert r.save
+    
     assert_raises RuntimeError do version.restore end
-    #assert_nothing_raised do
-      version.restore(perform_validations = false) #end
+    assert_nothing_raised do version.restore(perform_validations = false) end
   end
 
   def test_save_without_revision

data/test/versioned_test.rb

@@ -29,14 +29,11 @@ class VersionedTest < ActiveSupport::TestCase
 
   def test_rollback_with_version_number
     p = pages(:welcome)
-    versioncount = p.versions.count
     assert_equal 24, p.version
     assert_equal 'Welcome to the weblog', p.title
 
     assert p.revert_to!(23), "Couldn't revert to 23"
-    assert p.reload
-    assert_equal versioncount + 1, p.versions.count
-    assert_equal 25, p.version
+    assert_equal 23, p.version
     assert_equal 'Welcome to the weblg', p.title
   end
 
@@ -59,14 +56,11 @@ class VersionedTest < ActiveSupport::TestCase
 
   def test_rollback_with_version_class
     p = pages(:welcome)
-    versioncount = p.versions.count
     assert_equal 24, p.version
     assert_equal 'Welcome to the weblog', p.title
 
     assert p.revert_to!(p.versions.find_by_version(23)), "Couldn't revert to 23"
-    assert p.reload
-    assert_equal versioncount + 1, p.versions.count
-    assert_equal 25, p.version
+    assert_equal 23, p.version
     assert_equal 'Welcome to the weblg', p.title
   end
 
@@ -87,7 +81,7 @@ class VersionedTest < ActiveSupport::TestCase
     assert_equal 'Welcome to the weblog', p.title
     assert_equal 'LockedPage', p.versions.first.version_type
 
-    assert p.revert_to!(p.versions.first.version), "Couldn't revert to 23"
+    assert p.revert_to!(p.versions.first.lock_version), "Couldn't revert to 23"
     assert_equal 'Welcome to the weblg', p.title
     assert_equal 'LockedPage', p.versions.first.version_type
   end
@@ -114,7 +108,7 @@ class VersionedTest < ActiveSupport::TestCase
     p = locked_pages(:thinking)
     assert_equal 'So I was thinking', p.title
 
-    assert p.revert_to!(p.versions.first.version), "Couldn't revert to 1"
+    assert p.revert_to!(p.versions.first.lock_version), "Couldn't revert to 1"
     assert_equal 'So I was thinking!!!', p.title
     assert_equal 'SpecialLockedPage', p.versions.first.version_type
   end
@@ -208,7 +202,7 @@ class VersionedTest < ActiveSupport::TestCase
       p.title = "title#{i}"
       p.save
       assert_equal "title#{i}", p.title
-      assert_equal (i+4), p.version
+      assert_equal (i+4), p.lock_version
       assert p.versions(true).size <= 2, "locked version can only store 2 versions"
     end
   end
@@ -221,25 +215,25 @@ class VersionedTest < ActiveSupport::TestCase
 
   def test_track_altered_attributes
     p = LockedPage.create! :title => "title"
-    assert_equal 1, p.version
+    assert_equal 1, p.lock_version
     assert_equal 1, p.versions(true).size
 
     p.body = 'whoa'
     assert !p.save_version?
     p.save
-    assert_equal 1, p.version # no increment, because we're not using lock_version column
+    assert_equal 2, p.lock_version # still increments version because of optimistic locking
     assert_equal 1, p.versions(true).size
 
     p.title = 'updated title'
     assert p.save_version?
     p.save
-    assert_equal 2, p.version
-    assert_equal 2, p.versions(true).size
+    assert_equal 3, p.lock_version
+    assert_equal 1, p.versions(true).size # version 1 deleted
 
     p.title = 'updated title!'
     assert p.save_version?
     p.save
-    assert_equal 3, p.version
+    assert_equal 4, p.lock_version
     assert_equal 2, p.versions(true).size # version 1 deleted
   end
 
@@ -279,7 +273,7 @@ class VersionedTest < ActiveSupport::TestCase
 
     association = Widget.reflect_on_association(:versions)
     options = association.options
-    #assert_equal :nullify, options[:dependent] #Removed! we do not nullify the foreign key, because on restore we want to set the correct original ID
+    assert_equal :nullify, options[:dependent]
     assert_equal 'version desc', options[:order]
     assert_equal 'widget_id', options[:foreign_key]
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rtiss_acts_as_versioned
 version: !ruby/object:Gem::Version
-  version: 0.7.9
+  version: 0.8.0
 platform: ruby
 authors:
 - Rick Olson
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-18 00:00:00.000000000 Z
+date: 2014-10-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord