rtiss_acts_as_versioned 0.9.3 → 0.10.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 85c837eaad50a545769f14911ea26e8bd6d03344
-  data.tar.gz: d3dd30fd2e944aa691b4db979f9da20337f240fd
+SHA256:
+  metadata.gz: 9cb2135a1af395ec8595624054f61c3e734f46e92afb672eb88c100ec022bf45
+  data.tar.gz: 7281b3e9f959d0927ccb11ea403ea1f2a3bae706fc6e82fda93628a783ee4384
 SHA512:
-  metadata.gz: 43805ee66159f18b492621ae1b3ab7a90f8437e0b53c3c1b24c81abb6ec82685c2585c5f644fde0365746bfe4feb8e89fe224301a16b8164ef93e0e8ef36207e
-  data.tar.gz: c0c1fd0bcafa91533e72d12c71ffe66f366a1ef2089702d0b8bf422043447752bf308f79d1f942324481ab8db23078a800df4d7d470a8c2997d805684919f3b0
+  metadata.gz: c081c4d01d6dbd52000378b43d1ce1fd462fe2932f118c8cb3f385c6f37d0780de3ff22c918e22e632436a2cfd633b3d5a48a52fb31983477f0179248332ea94
+  data.tar.gz: a85c82617e04ee8a10f7f62df558b5e2c5a884e7c932ec8ce82fd6d3f6a9fe1008b4cd1908cec67f48f3612355dcb9577edfb13b0bb6736987603d2f75542964

data/README.md

@@ -0,0 +1,23 @@
+# rtiss_acts_as_versioned
+
+This library adds simple versioning to an ActiveRecord module.  ActiveRecord is required.
+
+This is the patched version for rtiss.
+
+Versions 0.9.x (master branch) are for Rails 4.x - 6.x
+Versions 0.10.x (master branch) are for Rails >= 6.0 and Ruby >= 3.1.6
+
+### Resources
+
+#### Install
+
+`gem 'rtiss_acts_as_versioned', '0.10.1'`
+
+
+#### GitHub
+
+* http://github.com/technoweenie/acts_as_versioned
+
+#### Rubygems
+
+* https://rubygems.org/gems/rtiss_acts_as_versioned

data/Rakefile

@@ -1,6 +1,7 @@
 require 'rubygems'
 require 'rake'
 require 'date'
+require 'rtiss_acts_as_versioned/version'
 
 #############################################################################
 #
@@ -13,8 +14,7 @@ def name
 end
 
 def version
-  line = File.read("lib//#{name}.rb")[/^\s*VERSION\s*=\s*.*/]
-  line.match(/.*VERSION\s*=\s*['"](.*)['"]/)[1]
+  ActiveRecord::Acts::Versioned::VERSION
 end
 
 def date
@@ -122,11 +122,11 @@ task :gemspec => :validate do
 end
 
 task :validate do
-  libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
-  unless libfiles.empty?
-    puts "Directory `lib` should only contain a `/#{name}.rb` file and `/#{name}` dir."
-    exit!
-  end
+  # libfiles = Dir['lib/*'] - ["lib/#{name}.rb", "lib/#{name}"]
+  # unless libfiles.empty?
+  #   puts "Directory `lib` should only contain a `/#{name}.rb` file and `/#{name}` dir."
+  #   exit!
+  # end
   unless Dir['VERSION*'].empty?
     puts "A `VERSION` file at root level violates Gem best practices."
     exit!

data/init.rb

@@ -1,2 +1,3 @@
-# encoding: utf-8
-require 'rtiss_acts_as_versioned'
+Dir.glob(File.expand_path("lib/**/*.rb")).each do |file|
+  require file
+end

data/lib/rtiss_acts_as_versioned/act_methods.rb

@@ -0,0 +1,289 @@
+module ActiveRecord
+  module Acts
+    module Versioned
+      module ActMethods
+        def self.included(base) # :nodoc:
+          base.extend ClassMethods
+        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
+            @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)
+            if rev.respond_to? :updated_at=
+              rev.updated_at = Time.now
+            end
+            rev.save
+          end
+        end
+
+        def set_deleted_flag
+          return if self.id.nil?
+
+          rev = self.class.versioned_class.new
+          clone_versioned_model(self, rev)
+          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)
+          if rev.respond_to? :updated_at=
+            rev.updated_at = Time.now
+          end
+          rev.save
+        end
+
+        # Clears old revisions if a limit is set with the :limit option in <tt>acts_as_versioned</tt>.
+        # Override this method to set your own criteria for clearing old versions.
+        def clear_old_versions
+          return if self.class.max_version_limit == 0
+          excess_baggage = send(self.class.version_column).to_i - self.class.max_version_limit
+          if excess_baggage > 0
+            self.class.versioned_class.delete_all ["#{self.class.version_column} <= ? and #{self.class.versioned_foreign_key} = ?", excess_baggage, id]
+          end
+        end
+
+        # 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
+            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))
+          true
+        end
+
+        # 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
+        end
+
+        # Temporarily turns off Optimistic Locking while saving.  Used when reverting so that a new version is not created.
+        def save_without_revision(perform_validation = true)
+          ret = false
+          without_locking do
+            without_revision do
+              ret = save(validate: perform_validation)
+            end
+          end
+          ret
+        end
+
+        def save_without_revision!
+          without_locking do
+            without_revision do
+              save!
+            end
+          end
+        end
+
+        def altered?
+          track_altered_attributes ? (version_if_changed - changed).length < version_if_changed.length : changed?
+        end
+
+        # Clones a model.  Used when saving a new version or reverting a model's version.
+        def clone_versioned_model(orig_model, new_model)
+          self.class.versioned_columns.each do |col|
+            new_model.send("#{col.name}=", orig_model.send(col.name)) if orig_model.has_attribute?(col.name)
+          end
+
+          clone_inheritance_column(orig_model, new_model)
+        end
+
+        def clone_inheritance_column(orig_model, new_model)
+          if orig_model.is_a?(self.class.versioned_class) && new_model.class.column_names.include?(new_model.class.inheritance_column.to_s)
+            new_model[new_model.class.inheritance_column] = orig_model[self.class.versioned_inheritance_column]
+          elsif new_model.is_a?(self.class.versioned_class) && new_model.class.column_names.include?(self.class.versioned_inheritance_column.to_s)
+            new_model[self.class.versioned_inheritance_column] = orig_model[orig_model.class.inheritance_column]
+          end
+        end
+
+        # Checks whether a new version shall be saved or not.  Calls <tt>version_condition_met?</tt> and <tt>changed?</tt>.
+        def save_version?
+          version_condition_met? && altered?
+        end
+
+        # Checks condition set in the :if option to check whether a revision should be created or not.  Override this for
+        # custom version condition checking.
+        def version_condition_met?
+          case
+          when version_condition.is_a?(Symbol)
+            send(version_condition)
+          when version_condition.respond_to?(:call) && (version_condition.arity == 1 || version_condition.arity == -1)
+            version_condition.call(self)
+          else
+            version_condition
+          end
+        end
+
+        # Executes the block with the versioning callbacks disabled.
+        #
+        #   @foo.without_revision do
+        #     @foo.save
+        #   end
+        #
+        def without_revision(&block)
+          self.class.without_revision(&block)
+        end
+
+        # Turns off optimistic locking for the duration of the block
+        #
+        #   @foo.without_locking do
+        #     @foo.save
+        #   end
+        #
+        def without_locking(&block)
+          self.class.without_locking(&block)
+        end
+
+        def empty_callback() end #:nodoc:
+
+        def find_newest_version
+          return nil if self.id.nil?
+
+          self.class.versioned_class.where("#{self.class.versioned_foreign_key} = #{self.id}").order("#{self.version_column} DESC").first
+        end
+
+        def highest_version
+          find_newest_version&.version || -1
+        end
+
+        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
+          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
+
+        # 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
+          def versioned_columns
+            @versioned_columns ||= columns.select { |c| !non_versioned_columns.include?(c.name) }
+          end
+
+          # Returns an instance of the dynamic versioned model
+          def versioned_class
+            const_get versioned_class_name
+          end
+
+          def restore_deleted(id)
+            version_record = versioned_class.where("#{versioned_foreign_key} = #{id}").order("#{self.version_column} DESC").first
+            version_record.restore
+          end
+
+          def restore_deleted_version(id, version)
+            version_record = versioned_class.where("#{versioned_foreign_key} = #{id} and #{self.version_column} = #{version}").first
+            version_record.restore
+          end
+
+          # Executes the block with the versioning callbacks disabled.
+          #
+          #   Foo.without_revision do
+          #     @foo.save
+          #   end
+          #
+          def without_revision(&block)
+            class_eval do
+              CALLBACKS.each do |attr_name|
+                alias_method "orig_#{attr_name}".to_sym, attr_name
+                alias_method attr_name, :empty_callback
+              end
+            end
+            block.call
+          ensure
+            class_eval do
+              CALLBACKS.each do |attr_name|
+                alias_method attr_name, "orig_#{attr_name}".to_sym
+              end
+            end
+          end
+
+          # Turns off optimistic locking for the duration of the block
+          #
+          #   Foo.without_locking do
+          #     @foo.save
+          #   end
+          #
+          def without_locking(&block)
+            current = ActiveRecord::Base.lock_optimistically
+            ActiveRecord::Base.lock_optimistically = false if current
+            begin
+              block.call
+            ensure
+              ActiveRecord::Base.lock_optimistically = true if current
+            end
+          end
+
+          # Rake migration task to create the versioned table using options passed to acts_as_versioned
+          def create_versioned_table(create_table_options = {})
+            # create version column in main table if it does not exist
+            unless self.column_names.find { |c| [version_column.to_s, 'lock_version'].include? c }
+              self.connection.add_column table_name, version_column, :integer
+              self.reset_column_information
+            end
+
+            return if connection.table_exists?(versioned_table_name)
+
+            self.connection.create_table(versioned_table_name, **create_table_options) do |t|
+              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
+            end
+
+            self.versioned_columns.each do |col|
+              self.connection.add_column versioned_table_name, col.name, col.type,
+                                         limit: col.limit,
+                                         default: col.default,
+                                         scale: col.scale,
+                                         precision: col.precision
+            end
+
+            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,
+                                         scale: type_col.scale,
+                                         precision: type_col.precision
+            end
+          end
+
+          # Rake migration task to drop the versioned table
+          def drop_versioned_table
+            self.connection.drop_table versioned_table_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rtiss_acts_as_versioned/version.rb

@@ -0,0 +1,7 @@
+module ActiveRecord
+  module Acts
+    module Versioned
+      VERSION = '0.10.2'
+    end
+  end
+end

data/lib/rtiss_acts_as_versioned.rb

@@ -20,7 +20,8 @@
 # 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.9.3'
+require_relative './rtiss_acts_as_versioned/act_methods'
+require_relative './rtiss_acts_as_versioned/version'
 
 module ActiveRecord #:nodoc:
   module Acts #:nodoc:
@@ -130,14 +131,14 @@ module ActiveRecord #:nodoc:
         #
         # == Database Schema
         #
-        # The model that you're versioning needs to have a 'version' attribute. The model is versioned 
-        # into a table called #{model}_versions where the model name is singlular. The _versions table should 
+        # The model that you're versioning needs to have a 'version' attribute. The model is versioned
+        # into a table called #{model}_versions where the model name is singlular. The _versions table should
         # contain all the fields you want versioned, the same version column, and a #{model}_id foreign key field.
         #
         # A lock_version field is also accepted if your model uses Optimistic Locking.  If your table uses Single Table inheritance,
         # then that field is reflected in the versioned model as 'versioned_type' by default.
         #
-        # Acts_as_versioned comes prepared with the ActiveRecord::Acts::Versioned::ActMethods::ClassMethods#create_versioned_table 
+        # Acts_as_versioned comes prepared with the ActiveRecord::Acts::Versioned::ActMethods::ClassMethods#create_versioned_table
         # method, perfect for a migration.  It will also create the version column if the main model does not already have it.
         #
         #   class AddVersions < ActiveRecord::Migration
@@ -146,16 +147,16 @@ module ActiveRecord #:nodoc:
         #       # that create_table does
         #       Post.create_versioned_table
         #     end
-        # 
+        #
         #     def self.down
         #       Post.drop_versioned_table
         #     end
         #   end
-        # 
+        #
         # == Changing What Fields Are Versioned
         #
-        # By default, acts_as_versioned will version all but these fields: 
-        # 
+        # By default, acts_as_versioned will version all but these fields:
+        #
         #   [self.primary_key, inheritance_column, 'version', 'lock_version', versioned_inheritance_column]
         #
         # You can add or change those by modifying #non_versioned_columns.  Note that this takes strings and not symbols.
@@ -164,7 +165,7 @@ module ActiveRecord #:nodoc:
         #     acts_as_versioned
         #     self.non_versioned_columns << 'comments_count'
         #   end
-        # 
+        #
         def acts_as_versioned(options = {}, &extension)
           # don't allow multiple calls
           return if self.included_modules.include?(ActiveRecord::Acts::Versioned::ActMethods)
@@ -197,10 +198,6 @@ module ActiveRecord #:nodoc:
 
           if block_given?
             extension_module_name = "#{versioned_class_name}Extension"
-            silence_warnings do
-              self.const_set(extension_module_name, Module.new(&extension))
-            end
-
             options[:extend] = self.const_get(extension_module_name)
           end
 
@@ -234,14 +231,17 @@ 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)
-              where("#{original_class.versioned_foreign_key} = ? and version < ?", version.send(original_class.versioned_foreign_key), version.version).order('version desc').first
+              where("#{original_class.versioned_foreign_key} = ? and #{self.version_column} < ?",
+                    version.send(original_class.versioned_foreign_key), version.version)
+                .order("#{self.version_column} desc").first
             end
 
             # find first version after the given version.
             def self.after(version)
-              where("#{original_class.versioned_foreign_key} = ? and version > ?", version.send(original_class.versioned_foreign_key), version.version).order('version').first
+              where("#{original_class.versioned_foreign_key} = ? and #{self.version_column} > ?",
+                    version.send(original_class.versioned_foreign_key), version.version)
+                .order(self.version_column).first
             end
 
             def previous
@@ -252,10 +252,6 @@ module ActiveRecord #:nodoc:
               self.class.after(self)
             end
 
-            def versions_count
-              page.version # TODO: ?!
-            end
-
             def restore(perform_validation = true)
               id = self.send(self.original_class.versioned_foreign_key)
               if self.original_class.exists?(id)
@@ -311,342 +307,8 @@ module ActiveRecord #:nodoc:
           versioned_class.sequence_name = version_sequence_name if version_sequence_name
         end
       end
-
-      module ActMethods
-        def self.included(base) # :nodoc:
-          base.extend ClassMethods
-        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
-            @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)
-            if rev.respond_to? :updated_at=
-              rev.updated_at = Time.now
-            end
-            rev.save
-          end
-        end
-
-        def set_deleted_flag
-          return if self.id.nil?
-
-          rev = self.class.versioned_class.new
-          clone_versioned_model(self, rev)
-          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)
-          if rev.respond_to? :updated_at=
-            rev.updated_at = Time.now
-          end
-          rev.save
-        end
-
-        # Clears old revisions if a limit is set with the :limit option in <tt>acts_as_versioned</tt>.
-        # Override this method to set your own criteria for clearing old versions.
-        def clear_old_versions
-          return if self.class.max_version_limit == 0
-          excess_baggage = send(self.class.version_column).to_i - self.class.max_version_limit
-          if excess_baggage > 0
-            self.class.versioned_class.delete_all ["#{self.class.version_column} <= ? and #{self.class.versioned_foreign_key} = ?", excess_baggage, id]
-          end
-        end
-
-        # 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
-            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))
-          true
-        end
-
-        # 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
-        end
-
-        # Temporarily turns off Optimistic Locking while saving.  Used when reverting so that a new version is not created.
-        def save_without_revision(perform_validation = true)
-          ret = false
-          without_locking do
-            without_revision do
-              ret = save(:validate => perform_validation)
-            end
-          end
-          return ret
-        end
-
-        def save_without_revision!
-          without_locking do
-            without_revision do
-              save!
-            end
-          end
-        end
-        
-        def altered?
-          track_altered_attributes ? (version_if_changed - changed).length < version_if_changed.length : changed?
-        end
-
-        # Clones a model.  Used when saving a new version or reverting a model's version.
-        def clone_versioned_model(orig_model, new_model)
-          self.class.versioned_columns.each do |col|
-            new_model.send("#{col.name}=", orig_model.send(col.name)) if orig_model.has_attribute?(col.name)
-          end
-
-          clone_inheritance_column(orig_model, new_model)
-        end
-
-        def clone_inheritance_column(orig_model, new_model)
-          if orig_model.is_a?(self.class.versioned_class) && new_model.class.column_names.include?(new_model.class.inheritance_column.to_s)
-            new_model[new_model.class.inheritance_column] = orig_model[self.class.versioned_inheritance_column]
-          elsif new_model.is_a?(self.class.versioned_class) && new_model.class.column_names.include?(self.class.versioned_inheritance_column.to_s)
-            new_model[self.class.versioned_inheritance_column] = orig_model[orig_model.class.inheritance_column]
-          end
-        end
-
-        # Checks whether a new version shall be saved or not.  Calls <tt>version_condition_met?</tt> and <tt>changed?</tt>.
-        def save_version?
-          version_condition_met? && altered?
-        end
-
-        # Checks condition set in the :if option to check whether a revision should be created or not.  Override this for
-        # custom version condition checking.
-        def version_condition_met?
-          case
-          when version_condition.is_a?(Symbol)
-            send(version_condition)
-          when version_condition.respond_to?(:call) && (version_condition.arity == 1 || version_condition.arity == -1)
-            version_condition.call(self)
-          else
-            version_condition
-          end
-        end
-
-        # Executes the block with the versioning callbacks disabled.
-        #
-        #   @foo.without_revision do
-        #     @foo.save
-        #   end
-        #
-        def without_revision(&block)
-          self.class.without_revision(&block)
-        end
-
-        # Turns off optimistic locking for the duration of the block
-        #
-        #   @foo.without_locking do
-        #     @foo.save
-        #   end
-        #
-        def without_locking(&block)
-          self.class.without_locking(&block)
-        end
-
-        def empty_callback() end #:nodoc:
-
-=begin
-# Alte finder-Syntax ab Rails 5 nicht mehr verwendbar.
-# Assoziation versions stattdessen verwenden
-        def find_versions(*args)
-          return [] if self.id.nil?
-
-          options = args.extract_options!
-          version_condition = "#{self.class.versioned_foreign_key} = #{self.id}"
-          if options[:conditions]
-            options[:conditions] += " and #{version_condition}"
-          else
-            options[:conditions] = version_condition
-          end
-          if args.first.is_a?(Symbol)
-            versions.find(args.first, options)
-          else # TODO: is_a?(Fixnum)
-            versions.find(options)
-          end
-        end
-=end
-
-        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
-        end
-
-        def highest_version
-          v = find_newest_version
-          if v then 
-            v.version 
-          else 
-            -1
-          end
-        end
-
-        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
-          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
-
-        # 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
-          def versioned_columns
-            @versioned_columns ||= columns.select { |c| !non_versioned_columns.include?(c.name) }
-          end
-
-          # Returns an instance of the dynamic versioned model
-          def versioned_class
-            const_get versioned_class_name
-          end
-
-          # Rake migration task to create the versioned table using options passed to acts_as_versioned
-          def create_versioned_table(create_table_options = {})
-            # create version column in main table if it does not exist
-            if !self.content_columns.find { |c| [version_column.to_s, 'lock_version'].include? c.name }
-              self.connection.add_column table_name, version_column, :integer
-              self.reset_column_information
-            end
-
-            return if connection.table_exists?(versioned_table_name)
-            
-            self.connection.create_table(versioned_table_name, create_table_options) do |t|
-              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
-            end
-
-            self.versioned_columns.each do |col|
-              self.connection.add_column versioned_table_name, col.name, col.type, 
-                :limit     => col.limit, 
-                :default   => col.default,
-                :scale     => col.scale,
-                :precision => col.precision
-            end
-
-            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,
-                :scale     => type_col.scale,
-                :precision => type_col.precision
-            end
-            
-            #self.connection.add_index versioned_table_name, versioned_foreign_key
-          end
-
-          # Rake migration task to drop the versioned table
-          def drop_versioned_table
-            self.connection.drop_table versioned_table_name
-          end
-
-          def restore_deleted(id)
-            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.where("#{versioned_foreign_key} = #{id} and version = #{version}").first
-            version_record.restore
-          end
-
-          # Executes the block with the versioning callbacks disabled.
-          #
-          #   Foo.without_revision do
-          #     @foo.save
-          #   end
-          #
-          def without_revision(&block)
-            class_eval do 
-              CALLBACKS.each do |attr_name|
-                alias_method "orig_#{attr_name}".to_sym, attr_name
-                alias_method attr_name, :empty_callback
-              end
-            end
-            block.call
-          ensure
-            class_eval do 
-              CALLBACKS.each do |attr_name|
-                alias_method attr_name, "orig_#{attr_name}".to_sym
-              end
-            end
-          end
-
-          # Turns off optimistic locking for the duration of the block
-          #
-          #   Foo.without_locking do
-          #     @foo.save
-          #   end
-          #
-          def without_locking(&block)
-            current = ActiveRecord::Base.lock_optimistically
-            ActiveRecord::Base.lock_optimistically = false if current
-            begin
-              block.call
-            ensure
-              ActiveRecord::Base.lock_optimistically = true if current
-            end
-          end
-        end
-      end
     end
   end
 end
 
-# TISS extension: do not pull this.
-module ActiveRecord #:nodoc:
-  module ConnectionAdapters #:nodoc:
-    class TableDefinition
-      ## Erzeugt 4 Spalten created_at, updated_at, version, mutator_id die in 
-      ## jeder Daten-Tabelle notwendig sind. Verwendung:
-      ##  create_table :adresse do |t|
-      ##    t.standard_spalten
-      ##    t.string strasse, :size=>120
-      ##    t.string plz, :size=>4
-      ##  end
-      def standard_spalten
-        column(:created_at, :datetime)
-        column(:updated_at, :datetime)
-        column(:version, :integer, :default=>1)
-        column(:mutator_id, :integer, :default=>0)
-      end
-    end
-  end
-end
-
-
-ActiveRecord::Base.send :include, ActiveRecord::Acts::Versioned
+ActiveRecord::Base.send :include, ActiveRecord::Acts::Versioned

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.9.3'
-  s.date              = '2024-08-26'
+  s.version           = '0.10.2'
+  s.date              = '2026-01-20'
   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).
@@ -29,27 +29,27 @@ to use technoweenie's version (can be found also on github)"
   s.homepage = 'http://github.com/rtiss/rtiss_acts_as_versioned'
   s.require_paths = ["lib"]
   s.rdoc_options = ["--charset=UTF-8"]
-  s.extra_rdoc_files = %w[README MIT-LICENSE CHANGELOG]
+  s.extra_rdoc_files = %w[README.md MIT-LICENSE]
 
-  s.add_dependency 'activerecord', ">= 4.2.5"
-  s.add_development_dependency 'sqlite3-ruby', "~> 1.3.1"
-  s.add_development_dependency 'rails', "~> 4.2.5"
+  s.add_dependency 'activerecord', ">= 7.1.6"
+  s.add_development_dependency 'sqlite3', '~> 2.7'
+  s.add_development_dependency 'rails', "~> 7.1.6"
   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
   ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
   # = MANIFEST =
   s.files = %w[
-    CHANGELOG
     Gemfile
     MIT-LICENSE
-    README
+    README.md
     RUNNING_UNIT_TESTS
     Rakefile
     init.rb
     lib/rtiss_acts_as_versioned.rb
+    lib/rtiss_acts_as_versioned/act_methods.rb
+    lib/rtiss_acts_as_versioned/version.rb
     rtiss_acts_as_versioned.gemspec
     test/abstract_unit.rb
     test/database.yml

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rtiss_acts_as_versioned
 version: !ruby/object:Gem::Version
-  version: 0.9.3
+  version: 0.10.2
 platform: ruby
 authors:
 - Rick Olson
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2024-08-26 00:00:00.000000000 Z
+date: 2026-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -18,42 +18,42 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.5
+        version: 7.1.6
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 4.2.5
+        version: 7.1.6
 - !ruby/object:Gem::Dependency
-  name: sqlite3-ruby
+  name: sqlite3
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.1
+        version: '2.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.3.1
+        version: '2.7'
 - !ruby/object:Gem::Dependency
   name: rails
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.2.5
+        version: 7.1.6
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.2.5
+        version: 7.1.6
 - !ruby/object:Gem::Dependency
   name: activerecord-testcase
   requirement: !ruby/object:Gem::Requirement
@@ -68,20 +68,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         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
@@ -92,18 +78,18 @@ email: igor.jancev@tuwien.ac.at
 executables: []
 extensions: []
 extra_rdoc_files:
-- README
+- README.md
 - MIT-LICENSE
-- CHANGELOG
 files:
-- CHANGELOG
 - Gemfile
 - MIT-LICENSE
-- README
+- README.md
 - RUNNING_UNIT_TESTS
 - Rakefile
 - init.rb
 - lib/rtiss_acts_as_versioned.rb
+- lib/rtiss_acts_as_versioned/act_methods.rb
+- lib/rtiss_acts_as_versioned/version.rb
 - rtiss_acts_as_versioned.gemspec
 - test/abstract_unit.rb
 - test/database.yml
@@ -143,8 +129,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: rtiss_acts_as_versioned
-rubygems_version: 2.6.14.4
+rubygems_version: 3.3.27
 signing_key: 
 specification_version: 4
 summary: Add simple versioning to ActiveRecord models (TISS version).

data/CHANGELOG

@@ -1,84 +0,0 @@
-*GIT* (version numbers are overrated)
-
-* 0.6 (19 Jul 2010) Rails 3 refactoring by gvarela!
-
-* (16 Jun 2008) Backwards Compatibility is overrated (big updates for rails 2.1)
-
-  * Use ActiveRecord 2.1's dirty attribute checking instead [Asa Calow]
-  * Remove last traces of #non_versioned_fields
-  * Remove AR::Base.find_version and AR::Base.find_versions, rely on AR association proxies and named_scope
-  * Remove #versions_count, rely on AR association counter caching.
-  * Remove #versioned_attributes, basically the same as AR::Base.versioned_columns
-
-* (5 Oct 2006) Allow customization of #versions association options [Dan Peterson]
-
-*0.5.1*
-
-* (8 Aug 2006) Versioned models now belong to the unversioned model.  @article_version.article.class => Article [Aslak Hellesoy]
-
-*0.5* # do versions even matter for plugins?
-
-* (21 Apr 2006) Added without_locking and without_revision methods.
-
-  Foo.without_revision do
-    @foo.update_attributes ...
-  end
-
-*0.4*
-
-* (28 March 2006) Rename non_versioned_fields to non_versioned_columns (old one is kept for compatibility).
-* (28 March 2006) Made explicit documentation note that string column names are required for non_versioned_columns.
-
-*0.3.1*
-
-* (7 Jan 2006) explicitly set :foreign_key option for the versioned model's belongs_to assocation for STI [Caged]
-* (7 Jan 2006) added tests to prove has_many :through joins work
-
-*0.3*
-
-* (2 Jan 2006) added ability to share a mixin with versioned class
-* (2 Jan 2006) changed the dynamic version model to MyModel::Version
-
-*0.2.4*
-
-* (27 Nov 2005) added note about possible destructive behavior of if_changed? [Michael Schuerig]
-
-*0.2.3*
-
-* (12 Nov 2005) fixed bug with old behavior of #blank? [Michael Schuerig]
-* (12 Nov 2005) updated tests to use ActiveRecord Schema
-
-*0.2.2*
-
-* (3 Nov 2005) added documentation note to #acts_as_versioned [Martin Jul]
-
-*0.2.1*
-
-* (6 Oct 2005) renamed dirty? to changed? to keep it uniform.  it was aliased to keep it backwards compatible.
-
-*0.2* 
-
-* (6 Oct 2005)  added find_versions and find_version class methods.
-
-* (6 Oct 2005)  removed transaction from create_versioned_table().  
-  this way you can specify your own transaction around a group of operations.
-
-* (30 Sep 2005) fixed bug where find_versions() would order by 'version' twice. (found by Joe Clark)
-
-* (26 Sep 2005) added :sequence_name option to acts_as_versioned to set the sequence name on the versioned model
-
-*0.1.3* (18 Sep 2005)
-
-* First RubyForge release
-
-*0.1.2*
-
-* check if module is already included when acts_as_versioned is called
-
-*0.1.1*
-
-* Adding tests and rdocs
-
-*0.1* 
-
-* Initial transfer from Rails ticket: http://dev.rubyonrails.com/ticket/1974

data/README

@@ -1,37 +0,0 @@
-= acts_as_versioned
-
-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
-Versions 0.9.x (master branch) are for rails 5.x (also works with rails 4.x)
-
-== Resources
-
-Install
-
-* gem install acts_as_versioned
-
-<3 GitHub
-
-* http://github.com/technoweenie/acts_as_versioned
-
-Gemcutter FTW
-
-* http://gemcutter.org/gems/acts_as_versioned
-
-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