rtiss_acts_as_versioned 0.7.7 → 0.7.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 85c1fb778a88b8b161aa9afc0d75f4fb8f382a26
-  data.tar.gz: d874fef09609b09e01902b1a8913ad282833e961
+  metadata.gz: 2f630279fadaf312a0d49b69fe00dbdfadf0dde5
+  data.tar.gz: a464dd23cb736ad635080101e14ef751afaa8543
 SHA512:
-  metadata.gz: b07f42376af502402330d3ed5a89a785ea057fde9bdd6f8260e3da5186cb90b1b3dee89dff6bd75029ed458de5595cc393dba9eff1f315ab8c6c3421d1c6024f
-  data.tar.gz: 4aa282b90818ad67588f81da4fbd737267dea7e8dac0149a63c83ba767df48f85346aa44e0fe3847d94e3cb083876e388695d5c5feaf0d380777f61b9cc65a56
+  metadata.gz: 73332935aafa174653421081523e244544595e740b6003a8b6be1907168f2645f467bafe4e55c63decebba4ac1c344f5d1dbe22b62b00e9709e9ed3c1fa49ef5
+  data.tar.gz: 0699711f61e6b4cda088686fab69a7533da97ae31e69132a434455451da2f1925fbc727e190119f39fda0553069a5a11d65d40943516de1ba3324d6ada50682a

data/Rakefile

@@ -73,14 +73,6 @@ task :console do
   sh "irb -rubygems -r ./lib//#{name}.rb"
 end
 
-#############################################################################
-#
-# Custom tasks (add your own tasks here)
-#
-#############################################################################
-
-
-
 #############################################################################
 #
 # Packaging tasks
@@ -90,6 +82,7 @@ end
 task :release => :build do
   sh "git commit --allow-empty -a -m 'Release #{version}'"
   sh "git tag #{version}"
+  sh "git push origin master"
   sh "git push origin master --tags"
   sh "gem push pkg/#{name}-#{version}.gem"
 end

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.7'
+VERSION = '0.7.8'
 
 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_flag
+            :version_association_options, :version_if_changed, :deleted_in_original_table_flag, :record_restored_column
 
           self.versioned_class_name         = options[:class_name]  || "Version"
           self.versioned_foreign_key        = options[:foreign_key] || self.to_s.foreign_key
@@ -182,11 +182,14 @@ 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_flag = options[:record_restored_flag]     || 'record_restored'
+          self.record_restored_column       = options[:record_restored_column]     || '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
@@ -231,6 +234,7 @@ 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]
@@ -263,7 +267,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_flag.to_s
+              version_hash.delete self.original_class.record_restored_column.to_s
               version_hash.delete self.original_class.versioned_foreign_key.to_s
 
               restored_record = self.original_class.new(version_hash)
@@ -271,18 +275,26 @@ 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
 
-              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!
+            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)
             end
 
             def original_record_exists?
@@ -307,15 +319,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
-          if @saving_version
+        def save_version(save_this=false, deleted_flag=false, restored_from_version=nil)
+          if @saving_version || save_this
             @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}=", false)
-            rev.send("#{self.class.record_restored_flag}=", false)
+            rev.send("#{self.class.deleted_in_original_table_flag}=", deleted_flag)
+            rev.send("#{self.class.record_restored_column}=", restored_from_version)
             if rev.respond_to? :updated_at=
               rev.updated_at = Time.now
             end
@@ -331,7 +343,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_flag}=", false)
+          rev.send("#{self.class.record_restored_column}=", nil)
           if rev.respond_to? :updated_at=
             rev.updated_at = Time.now
           end
@@ -351,9 +363,11 @@ 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
-            return false unless version = versions.send("find_by_#{self.class.version_column}", version)
+            @reverted_from = version
+            return false unless version = versions.where(self.class.version_column => version).first
           end
           self.clone_versioned_model(version, self)
           send("#{self.class.version_column}=", version.send(self.class.version_column))
@@ -363,7 +377,13 @@ 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)
-          revert_to(version) ? save_without_revision : false
+          if revert_to(version)
+            set_new_version
+            save_without_revision
+            save_version(true, false, @reverted_from)
+          else
+            false
+          end
         end
 
         # Temporarily turns off Optimistic Locking while saving.  Used when reverting so that a new version is not created.
@@ -466,7 +486,7 @@ module ActiveRecord #:nodoc:
         def find_newest_version
           return nil if self.id.nil?
 
-          self.class.versioned_class.find(:first, :conditions => "#{self.class.versioned_foreign_key} = #{self.id}", :order => "version DESC")
+          self.class.versioned_class.where("#{self.class.versioned_foreign_key} = #{self.id}").order("version DESC").first
         end
 
         def highest_version
@@ -481,22 +501,22 @@ module ActiveRecord #:nodoc:
         def find_version(version)
           return nil if self.id.nil?
 
-          ret = self.class.versioned_class.find(:first, :conditions => "#{self.class.versioned_foreign_key} = #{self.id} and version=#{version}") # TODO: version column
+          ret = self.class.versioned_class.where("#{self.class.versioned_foreign_key} = #{self.id} and #{self.class.version_column}=#{version}").first
           raise "find_version: version #{version} not found in database" unless ret
           ret
         end
 
         protected
-          # 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
+        # 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
 
-          # 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
@@ -523,7 +543,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_flag, :boolean, :default => false
+              t.column record_restored_column, :integer, :default => nil
             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.7'
-  s.date              = '2014-11-03'
+  s.version           = '0.7.8'
+  s.date              = '2014-11-18'
   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,10 +1,12 @@
 welcome:
   id: 1
   title: Welcome to the weblog
-  lock_version: 24
+  version: 24
+  lock_version: 1
   type: LockedPage
 thinking:
   id: 2
   title: So I was thinking
-  lock_version: 24
+  version: 24
+  lock_version: 1
   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
-  lock_version: 23
+  version: 23
   version_type: LockedPage
 
 welcome_2:
   id: 2
   page_id: 1
   title: Welcome to the weblog
-  lock_version: 24
+  version: 24
   version_type: LockedPage
 
 thinking_1:
   id: 3
   page_id: 2
   title: So I was thinking!!!
-  lock_version: 23
+  version: 23
   version_type: SpecialLockedPage
 
 thinking_2:
   id: 4
   page_id: 2
   title: So I was thinking
-  lock_version: 24
+  version: 24
   version_type: SpecialLockedPage

data/test/fixtures/page.rb

@@ -29,7 +29,6 @@ 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 => {
-    :dependent => :nullify, :order => 'version desc'
+    :order => 'version desc' # Don't nullify the foreign key column when deleting the original record! :dependent => :nullify option removed
   }
   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, :boolean
+    t.column :record_restored, :integer, :precision => 38,  :scale => 0, :default => nil
   end
   
   add_index :pages_h, [:page_id, :version], :unique => true
@@ -31,6 +31,7 @@ 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
@@ -38,16 +39,17 @@ ActiveRecord::Schema.define(:version => 0) do
 
   create_table :locked_pages_revisions, :force => true do |t|
     t.column :page_id, :integer
-    t.column :lock_version, :integer
+    t.column :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, :boolean
+    t.column :record_restored, :integer, :precision => 38,  :scale => 0, :default => nil
   end
   
-  add_index :locked_pages_revisions, [:page_id, :lock_version], :unique => true
+  add_index :locked_pages_revisions, [:page_id, :version], :unique => true
 
   create_table :widgets, :force => true do |t|
     t.column :name, :string, :limit => 50
@@ -62,7 +64,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, :boolean
+    t.column :record_restored, :integer, :precision => 38,  :scale => 0, :default => nil
   end
   
   add_index :widgets_h, [:widget_id, :version], :unique => true
@@ -83,7 +85,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, :boolean
+    t.column :record_restored, :integer, :precision => 38,  :scale => 0, :default => nil
   end
   
   add_index :landmark_h, [:landmark_id, :version], :unique => true
@@ -111,7 +113,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.boolean  "record_restored",                 :precision => 1,  :scale => 0
+    t.integer  "record_restored",                           :precision => 38,  :scale => 0, :default => nil
     t.integer  "parent_id",                                 :precision => 38, :scale => 0
     t.string   "beschreibung_intern",       :limit => 4000
     t.string   "geltungsbereich",           :limit => 1000
@@ -144,7 +146,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.boolean  "record_restored",                 :precision => 1,  :scale => 0
+    t.integer  "record_restored",                           :precision => 38,  :scale => 0, :default => nil
     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,23 +106,63 @@ 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
-    assert v.deleted_in_original_table
+    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"
 
     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
@@ -193,7 +233,8 @@ class TissTest < ActiveSupport::TestCase
     assert r.save
     r.name = 'zak'
     assert r.save
-    assert_equal 2, r.versions.size 
+    r.reload
+    assert_equal 2, r.versions.size
     assert_equal 2, r.versions.count
   end
 
@@ -205,9 +246,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,11 +29,14 @@ 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_equal 23, p.version
+    assert p.reload
+    assert_equal versioncount + 1, p.versions.count
+    assert_equal 25, p.version
     assert_equal 'Welcome to the weblg', p.title
   end
 
@@ -56,11 +59,14 @@ 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_equal 23, p.version
+    assert p.reload
+    assert_equal versioncount + 1, p.versions.count
+    assert_equal 25, p.version
     assert_equal 'Welcome to the weblg', p.title
   end
 
@@ -81,7 +87,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.lock_version), "Couldn't revert to 23"
+    assert p.revert_to!(p.versions.first.version), "Couldn't revert to 23"
     assert_equal 'Welcome to the weblg', p.title
     assert_equal 'LockedPage', p.versions.first.version_type
   end
@@ -108,7 +114,7 @@ class VersionedTest < ActiveSupport::TestCase
     p = locked_pages(:thinking)
     assert_equal 'So I was thinking', p.title
 
-    assert p.revert_to!(p.versions.first.lock_version), "Couldn't revert to 1"
+    assert p.revert_to!(p.versions.first.version), "Couldn't revert to 1"
     assert_equal 'So I was thinking!!!', p.title
     assert_equal 'SpecialLockedPage', p.versions.first.version_type
   end
@@ -202,7 +208,7 @@ class VersionedTest < ActiveSupport::TestCase
       p.title = "title#{i}"
       p.save
       assert_equal "title#{i}", p.title
-      assert_equal (i+4), p.lock_version
+      assert_equal (i+4), p.version
       assert p.versions(true).size <= 2, "locked version can only store 2 versions"
     end
   end
@@ -215,25 +221,25 @@ class VersionedTest < ActiveSupport::TestCase
 
   def test_track_altered_attributes
     p = LockedPage.create! :title => "title"
-    assert_equal 1, p.lock_version
+    assert_equal 1, p.version
     assert_equal 1, p.versions(true).size
 
     p.body = 'whoa'
     assert !p.save_version?
     p.save
-    assert_equal 2, p.lock_version # still increments version because of optimistic locking
+    assert_equal 1, p.version # no increment, because we're not using lock_version column
     assert_equal 1, p.versions(true).size
 
     p.title = 'updated title'
     assert p.save_version?
     p.save
-    assert_equal 3, p.lock_version
-    assert_equal 1, p.versions(true).size # version 1 deleted
+    assert_equal 2, p.version
+    assert_equal 2, p.versions(true).size
 
     p.title = 'updated title!'
     assert p.save_version?
     p.save
-    assert_equal 4, p.lock_version
+    assert_equal 3, p.version
     assert_equal 2, p.versions(true).size # version 1 deleted
   end
 
@@ -273,7 +279,7 @@ class VersionedTest < ActiveSupport::TestCase
 
     association = Widget.reflect_on_association(:versions)
     options = association.options
-    assert_equal :nullify, options[:dependent]
+    #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 '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.7
+  version: 0.7.8
 platform: ruby
 authors:
 - Rick Olson
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-03 00:00:00.000000000 Z
+date: 2014-11-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord