rtiss_acts_as_versioned 0.8.2 → 0.8.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cac92ff6342270205cab079fb0f7ce7dba50bbd0
-  data.tar.gz: 2130ecc8fb34f759ddcf46dcabce01e349903ab8
+  metadata.gz: b9f5a6e965b68027705381bc7f298c863c4a72f1
+  data.tar.gz: d604439b36e5bd52fe5480dcf5e96a1a74c6f213
 SHA512:
-  metadata.gz: 860ff36bcf176300a9af52127515c6ee61534a7a6f039c75046d836e6c1624b09c046033756a9f10cd7c0a10802b96ede5bb6f7d6d4765fb0ece1e3c1e11c538
-  data.tar.gz: f17c24bc136814c0e84db5a44486add1131a0f87e1d559e6bc9c56c3de694319e8cf703a8294d126f941d755b8754611414e67ea04052f8e2305a74b42ccf707
+  metadata.gz: 59bcc2984591245b9dcfafde7e80330388fdff93ca952ba582b3759941dc5c575bc64ea13f7ceff5b6685ae5dcba10273d24bad8839e63ff8afb409b372bb1ea
+  data.tar.gz: e180bd6b6234db9488ce3e9beb9f40b2c4521e57161ab89346cd96b786208822c7340d64f6c9751fce5743f6cfa516b8920b2b8669b37867dfeaf183cd2fc71a

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

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.8.2'
+VERSION = '0.8.3'
 
 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
@@ -205,12 +208,12 @@ module ActiveRecord #:nodoc:
             has_many :versions, version_association_options do
               # finds earliest version of this record
               def earliest
-                @earliest ||= find(:first, :order => '#{version_column}')
+                @earliest ||= order('#{version_column}').first
               end
 
               # find latest version of this record
               def latest
-                @latest ||= find(:first, :order => '#{version_column} desc')
+                @latest ||= order('#{version_column} desc').first
               end
             end
             before_save  :set_new_version
@@ -231,15 +234,14 @@ 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]
+              where("#{original_class.versioned_foreign_key} = ? and version < ?", version.send(original_class.versioned_foreign_key), version.version).order('version desc').first
             end
 
             # find first version after the given version.
             def self.after(version)
-              find :first, :order => 'version',
-                :conditions => ["#{original_class.versioned_foreign_key} = ? and version > ?", version.send(original_class.versioned_foreign_key), version.version]
+              where("#{original_class.versioned_foreign_key} = ? and version > ?", version.send(original_class.versioned_foreign_key), version.version).order('version').first
             end
 
             def previous
@@ -263,7 +265,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 +273,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 +317,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 +341,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 +361,12 @@ 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
+            version = versions.where(self.class.version_column => version).first
+            return false unless version
           end
           self.clone_versioned_model(version, self)
           send("#{self.class.version_column}=", version.send(self.class.version_column))
@@ -363,7 +376,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.
@@ -451,7 +470,7 @@ module ActiveRecord #:nodoc:
 
           options = args.extract_options!
           version_condition = "#{self.class.versioned_foreign_key} = #{self.id}"
-          if options[:conditions] then
+          if options[:conditions]
             options[:conditions] += " and #{version_condition}"
           else
             options[:conditions] = version_condition
@@ -466,7 +485,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 +500,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,13 +542,13 @@ 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| 
               self.connection.add_column versioned_table_name, col.name, col.type, 
                 :limit     => col.limit, 
-                :default   => col.default,
+                :default   => col.cast_type.type_cast_from_database(col.default),  # convert strings to ruby types
                 :scale     => col.scale,
                 :precision => col.precision
             end
@@ -537,7 +556,7 @@ module ActiveRecord #:nodoc:
             if type_col = self.columns_hash[inheritance_column]
               self.connection.add_column versioned_table_name, versioned_inheritance_column, type_col.type, 
                 :limit     => type_col.limit, 
-                :default   => type_col.default,
+                :default   => type_col.cast_type.type_cast_from_database(type_col.default),  # convert strings to ruby types
                 :scale     => type_col.scale,
                 :precision => type_col.precision
             end
@@ -551,12 +570,12 @@ module ActiveRecord #:nodoc:
           end
 
           def restore_deleted(id)
-            version_record = versioned_class.find(:first, :conditions => "#{versioned_foreign_key} = #{id}", :order => "version DESC")
+            version_record = versioned_class.where("#{versioned_foreign_key} = #{id}").order("version DESC").first
             version_record.restore
           end
 
           def restore_deleted_version(id, version)
-            version_record = versioned_class.find(:first, :conditions => "#{versioned_foreign_key} = #{id} and version = #{version}")
+            version_record = versioned_class.where("#{versioned_foreign_key} = #{id} and version = #{version}").first
             version_record.restore
           end
 
@@ -604,7 +623,6 @@ module ActiveRecord #:nodoc:
 end
 
 # TISS extension: do not pull this.
-# TODO: Move to TISS app (initializer)
 module ActiveRecord #:nodoc:
   module ConnectionAdapters #:nodoc:
     class TableDefinition

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.8.2'
-  s.date              = '2014-11-18'
+  s.version           = '0.8.3'
+  s.date              = '2016-01-25'
   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).
@@ -31,10 +31,11 @@ to use technoweenie's version (can be found also on github)"
   s.rdoc_options = ["--charset=UTF-8"]
   s.extra_rdoc_files = %w[README MIT-LICENSE CHANGELOG]
 
-  s.add_dependency 'activerecord', ">= 3.0.9"
+  s.add_dependency 'activerecord', ">= 4.2.5"
   s.add_development_dependency 'sqlite3-ruby', "~> 1.3.1"
-  s.add_development_dependency 'rails', "~> 3.0.20"
-  s.add_development_dependency 'mysql', "~> 2.8.1"
+  s.add_development_dependency 'rails', "~> 4.2.5"
+  s.add_development_dependency 'activerecord-testcase'
+  s.add_development_dependency 'activerecord-deprecated_finders' # todo alte, hash-basierte finders auf die neue AR Query-API migrieren
 
   ## Leave this section as-is. It will be automatically generated from the
   ## contents of your Git repository via the gemspec task. DO NOT REMOVE
@@ -59,7 +60,7 @@ to use technoweenie's version (can be found also on github)"
     test/fixtures/locked_pages.yml
     test/fixtures/locked_pages_revisions.yml
     test/fixtures/locked_rolle.rb
-    test/fixtures/migrations/1_add_versioned_tables.rb
+    test/fixtures/migrations/2_add_versioned_tables.rb
     test/fixtures/page.rb
     test/fixtures/pages.yml
     test/fixtures/pages_h.yml

data/test/abstract_unit.rb

@@ -1,22 +1,17 @@
-require "rubygems"
 require "bundler"
 Bundler.setup(:default, :development)
 
 $:.unshift(File.dirname(__FILE__) + '/../lib')
-require 'test/unit'
+require 'minitest/autorun'
 require 'active_support'
 require 'active_record'
 require 'active_record/fixtures'
 require 'active_record/test_case'
-
-begin
-  require 'ruby-debug'
-  Debugger.start
-rescue LoadError
-end
-
+require 'active_record/deprecated_finders'
 require 'rtiss_acts_as_versioned'
 
+ActiveSupport::TestCase.test_order = :sorted
+
 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']}

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/locked_rolle.rb

@@ -1,6 +1,6 @@
 # Same as Rolle except for the presence of the lock_version field
 class LockedRolle < ActiveRecord::Base
-        set_table_name 'locked_rolle'
+	self.table_name = 'locked_rolle'
 	acts_as_versioned
 
 	validates_presence_of :name

data/test/fixtures/migrations/{1_add_versioned_tables.rb → 2_add_versioned_tables.rb}

@@ -1,6 +1,6 @@
 class AddVersionedTables < ActiveRecord::Migration
   def self.up
-    create_table("things") do |t|
+    create_table "things" do |t|
       t.column :title, :text
       t.column :price, :decimal, :precision => 7, :scale => 2
       t.column :type, :string

data/test/fixtures/page.rb

@@ -1,8 +1,9 @@
 class Page < ActiveRecord::Base
   belongs_to :author
-  has_many   :authors,  :through => :versions, :order => 'name'
+  has_many   :authors,  -> { order(:name)}, :through => :versions
   belongs_to :revisor,  :class_name => 'Author'
-  has_many   :revisors, :class_name => 'Author', :through => :versions, :order => 'name'
+  has_many   :revisors, -> { order(:name)}, :class_name => 'Author', :through => :versions
+
   acts_as_versioned :if => :feeling_good? do
     def self.included(base)
       base.cattr_accessor :feeling_good
@@ -29,7 +30,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/rolle.rb

@@ -1,5 +1,5 @@
 class Rolle < ActiveRecord::Base
-	set_table_name 'rolle'
+	self.table_name = 'rolle'
 	acts_as_versioned
 
 	validates_presence_of :name

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/migration_test.rb

@@ -8,39 +8,22 @@ if ActiveRecord::Base.connection.supports_migrations?
 
   class MigrationTest < ActiveSupport::TestCase
     self.use_transactional_fixtures = false
-    def teardown
-      if ActiveRecord::Base.connection.respond_to?(:initialize_schema_information)
-        ActiveRecord::Base.connection.initialize_schema_information
-        ActiveRecord::Base.connection.update "UPDATE schema_info SET version = 0"
-      else
-        ActiveRecord::Base.connection.initialize_schema_migrations_table
-        ActiveRecord::Base.connection.assume_migrated_upto_version(0)
-      end
-      
-      Thing.connection.drop_table "things" rescue nil
-      Thing.connection.drop_table "thing_versions" rescue nil
-      Thing.reset_column_information
-    end
-        
+
     def test_versioned_migration
-      assert_raises(ActiveRecord::StatementInvalid) { Thing.create :title => 'blah blah' }
       # take 'er up
-      ActiveRecord::Migrator.up(File.dirname(__FILE__) + '/fixtures/migrations/')
+      migrations_path = File.expand_path(File.dirname(__FILE__)) + '/fixtures/migrations'
+      require migrations_path + '/2_add_versioned_tables'
+      ActiveRecord::Migrator.new(:up, ActiveRecord::Migrator.migrations(migrations_path), 2).run
       t = Thing.create :title => 'blah blah', :price => 123.45, :type => 'Thing'
       assert_equal 1, t.versions.size
       
       # check that the price column has remembered its value correctly
       assert_equal t.price,  t.versions.first.price
       assert_equal t.title,  t.versions.first.title
-      assert_equal t[:type], t.versions.first[:type]
-      
+
       # make sure that the precision of the price column has been preserved
       assert_equal 7, Thing::Version.columns.find{|c| c.name == "price"}.precision
       assert_equal 2, Thing::Version.columns.find{|c| c.name == "price"}.scale
-
-      # now lets take 'er back down
-      ActiveRecord::Migrator.down(File.dirname(__FILE__) + '/fixtures/migrations/')
-      assert_raises(ActiveRecord::StatementInvalid) { Thing.create :title => 'blah blah' }
     end
   end
 end

data/test/schema.rb

@@ -1,4 +1,4 @@
-ActiveRecord::Schema.define(:version => 0) do
+ActiveRecord::Schema.define(:version => 1) do
   create_table :pages, :force => true do |t|
     t.column :version, :integer
     t.column :title, :string, :limit => 255
@@ -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

@@ -45,7 +45,7 @@ class TissTest < ActiveSupport::TestCase
   
   def test_deleted_in_original_table
     record = create_object('test deleted_in_orginal_table')
-    version_record = record.versions.find(:first)
+    version_record = record.versions.first
     assert version_record != nil
 
     assert !version_record.deleted_in_original_table
@@ -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

@@ -1,5 +1,6 @@
 require File.join(File.dirname(__FILE__), 'abstract_unit')
 require File.join(File.dirname(__FILE__), 'fixtures/page')
+require File.join(File.dirname(__FILE__), 'fixtures/landmark')
 require File.join(File.dirname(__FILE__), 'fixtures/widget')
 
 class VersionedTest < ActiveSupport::TestCase
@@ -29,11 +30,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 +60,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 +88,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 +115,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 +209,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 +222,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,8 +280,7 @@ class VersionedTest < ActiveSupport::TestCase
 
     association = Widget.reflect_on_association(:versions)
     options = association.options
-    assert_equal :nullify, options[:dependent]
-    assert_equal 'version desc', options[:order]
+    #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 'widget_id', options[:foreign_key]
 
     widget = Widget.create! :name => 'new widget'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rtiss_acts_as_versioned
 version: !ruby/object:Gem::Version
-  version: 0.8.2
+  version: 0.8.3
 platform: ruby
 authors:
 - Rick Olson
@@ -10,64 +10,78 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-11-18 00:00:00.000000000 Z
+date: 2016-01-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.9
+        version: 4.2.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 3.0.9
+        version: 4.2.5
 - !ruby/object:Gem::Dependency
   name: sqlite3-ruby
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.3.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 1.3.1
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.20
+        version: 4.2.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 3.0.20
+        version: 4.2.5
 - !ruby/object:Gem::Dependency
-  name: mysql
+  name: activerecord-testcase
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.8.1
+        version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ~>
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.8.1
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activerecord-deprecated_finders
+  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: "Add simple versioning to ActiveRecord models (TISS version).\n\nEach
   model has a to-many model named mymodel_h which records all changes \n(including
   destroys but not deletes) made to the model. This is the version\nused by http://tiss.tuwien.ac.at
@@ -100,7 +114,7 @@ files:
 - test/fixtures/locked_pages.yml
 - test/fixtures/locked_pages_revisions.yml
 - test/fixtures/locked_rolle.rb
-- test/fixtures/migrations/1_add_versioned_tables.rb
+- test/fixtures/migrations/2_add_versioned_tables.rb
 - test/fixtures/page.rb
 - test/fixtures/pages.yml
 - test/fixtures/pages_h.yml
@@ -115,17 +129,17 @@ licenses: []
 metadata: {}
 post_install_message: 
 rdoc_options:
-- --charset=UTF-8
+- "--charset=UTF-8"
 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: []
@@ -135,3 +149,4 @@ signing_key:
 specification_version: 4
 summary: Add simple versioning to ActiveRecord models (TISS version).
 test_files: []
+has_rdoc: