Making the user unit test pass

Leandro Santos · Antonio Terceiro
1 parent 5c9d49f0
Showing 12 changed files with 259 additions and 240 deletions Show diff stats
db/schema.rb
test/unit/user_test.rb
vendor/plugins/acts_as_versioned/CHANGELOG
vendor/plugins/acts_as_versioned/Rakefile
vendor/plugins/acts_as_versioned/lib/acts_as_versioned.rb
vendor/plugins/acts_as_versioned/test/abstract_unit.rb
vendor/plugins/acts_as_versioned/test/fixtures/landmarks.yml
vendor/plugins/acts_as_versioned/test/fixtures/locked_pages_revisions.yml
vendor/plugins/acts_as_versioned/test/fixtures/pages.yml
vendor/plugins/acts_as_versioned/test/migration_test.rb
vendor/plugins/acts_as_versioned/test/schema.rb
vendor/plugins/acts_as_versioned/test/versioned_test.rb
 # This file is auto-generated from the current state of the database. Instead of editing this file, 
-# please use the migrations feature of ActiveRecord to incrementally modify your database, and
+# please use the migrations feature of Active Record to incrementally modify your database, and
 # then regenerate this schema definition.
 #
 # Note that this schema.rb definition is the authoritative source for your database schema. If you need
@@ -131,8 +131,8 @@ ActiveRecord::Schema.define(:version =&gt; 69) do
     t.boolean "virtual",     :default => false
   end
  
-  add_index "categories_profiles", ["category_id"], :name => "index_categories_profiles_on_category_id"
   add_index "categories_profiles", ["profile_id"], :name => "index_categories_profiles_on_profile_id"
+  add_index "categories_profiles", ["category_id"], :name => "index_categories_profiles_on_category_id"
  
   create_table "comments", :force => true do |t|
     t.string   "title"
@@ -211,8 +211,8 @@ ActiveRecord::Schema.define(:version =&gt; 69) do
     t.datetime "updated_at"
   end
  
-  add_index "product_categorizations", ["category_id"], :name => "index_product_categorizations_on_category_id"
   add_index "product_categorizations", ["product_id"], :name => "index_product_categorizations_on_product_id"
+  add_index "product_categorizations", ["category_id"], :name => "index_product_categorizations_on_category_id"
  
   create_table "products", :force => true do |t|
     t.integer  "enterprise_id"
@@ -164,7 +164,8 @@ class UserTest &lt; Test::Unit::TestCase
  
   def test_should_encrypt_password_with_salted_sha1
     user = User.new(:login => 'lalala', :email => 'lalala@example.com', :password => 'test', :password_confirmation => 'test')
-    user.build_person(person_data)
+#TODO UPGRADE Leandro: I comment this code. The user model already create a person model
+#    user.build_person(person_data)
     user.stubs(:salt).returns('testsalt')
     user.save!
  
@@ -295,7 +296,8 @@ class UserTest &lt; Test::Unit::TestCase
   protected
     def new_user(options = {})
       user = User.new({ :login => 'quire', :email => 'quire@example.com', :password => 'quire', :password_confirmation => 'quire' }.merge(options))
-      user.build_person(person_data)
+#TODO UPGRADE Leandro: I comment this code. The user model already create a person model
+#      user.build_person(person_data)
       user.save
       user
     end
-*SVN* (version numbers are overrated)
+*GIT* (version numbers are overrated)
+
+* (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]
  
 require 'rubygems'
  
-Gem::manage_gems
-
 require 'rake/rdoctask'
 require 'rake/packagetask'
 require 'rake/gempackagetask'
@@ -66,7 +66,7 @@ module ActiveRecord #:nodoc:
     #
     # See ActiveRecord::Acts::Versioned::ClassMethods#acts_as_versioned for configuration options
     module Versioned
-      CALLBACKS = [:set_new_version, :save_version_on_create, :save_version?, :clear_changed_attributes]
+      CALLBACKS = [:set_new_version, :save_version, :save_version?]
       def self.included(base) # :nodoc:
         base.extend ClassMethods
       end
@@ -95,12 +95,7 @@ module ActiveRecord #:nodoc:
         #     end
         #
         # * <tt>if_changed</tt> - Simple way of specifying attributes that are required to be changed before saving a model.  This takes
-        #   either a symbol or array of symbols.  WARNING - This will attempt to overwrite any attribute setters you may have.  
-        #   Use this instead if you want to write your own attribute setters (and ignore if_changed):
-        # 
-        #     def name=(new_name)
-        #       write_changed_attribute :name, new_name
-        #     end
+        #   either a symbol or array of symbols.
         #
         # * <tt>extend</tt> - Lets you specify a module to be mixed in both the original and versioned models.  You can also just pass a block
         #   to create an anonymous mixin:
@@ -148,7 +143,7 @@ module ActiveRecord #:nodoc:
         #       # that create_table does
         #       Post.create_versioned_table
         #     end
-        #   
+        # 
         #     def self.down
         #       Post.drop_versioned_table
         #     end
@@ -172,21 +167,10 @@ module ActiveRecord #:nodoc:
           return if self.included_modules.include?(ActiveRecord::Acts::Versioned::ActMethods)
  
           send :include, ActiveRecord::Acts::Versioned::ActMethods
-          
-          cattr_accessor :versioned_class_name, :versioned_foreign_key, :versioned_table_name, :versioned_inheritance_column, 
-            :version_column, :max_version_limit, :track_changed_attributes, :version_condition, :version_sequence_name, :non_versioned_columns,
-            :version_association_options
-            
-          # legacy
-          alias_method :non_versioned_fields,  :non_versioned_columns
-          alias_method :non_versioned_fields=, :non_versioned_columns=
  
-          class << self
-            alias_method :non_versioned_fields,  :non_versioned_columns
-            alias_method :non_versioned_fields=, :non_versioned_columns=
-          end
-
-          send :attr_accessor, :changed_attributes
+          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
  
           self.versioned_class_name         = options[:class_name]  || "Version"
           self.versioned_foreign_key        = options[:foreign_key] || self.to_s.foreign_key
@@ -196,11 +180,10 @@ module ActiveRecord #:nodoc:
           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, 'version', 'lock_version', versioned_inheritance_column]
+          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)
           self.version_association_options  = {
                                                 :class_name  => "#{self.to_s}::#{versioned_class_name}",
                                                 :foreign_key => versioned_foreign_key,
-                                                :order       => 'version',
                                                 :dependent   => :delete_all
                                               }.merge(options[:association_options] || {})
  
@@ -209,40 +192,34 @@ module ActiveRecord #:nodoc:
             silence_warnings do
               self.const_set(extension_module_name, Module.new(&extension))
             end
-            
+
             options[:extend] = self.const_get(extension_module_name)
           end
  
-          class_eval do
+          class_eval <<-CLASS_METHODS
             has_many :versions, version_association_options do
               # finds earliest version of this record
               def earliest
-                @earliest ||= find(:first)
+                @earliest ||= find(:first, :order => '#{version_column}')
               end
-              
+
               # find latest version of this record
               def latest
-                @latest ||= find(:first, :order => 'version desc')
+                @latest ||= find(:first, :order => '#{version_column} desc')
               end
             end
             before_save  :set_new_version
-            after_create :save_version_on_create
-            after_update :save_version
+            after_save   :save_version
             after_save   :clear_old_versions
-            after_save   :clear_changed_attributes
-            
+
             unless options[:if_changed].nil?
-              self.track_changed_attributes = true
+              self.track_altered_attributes = true
               options[:if_changed] = [options[:if_changed]] unless options[:if_changed].is_a?(Array)
-              options[:if_changed].each do |attr_name|
-                define_method("#{attr_name}=") do |value|
-                  write_changed_attribute attr_name, value
-                end
-              end
+              self.version_if_changed = options[:if_changed].map(&:to_s)
             end
-            
+
             include options[:extend] if options[:extend].is_a?(Module)
-          end
+          CLASS_METHODS
  
           # create the dynamic versioned model
           const_set(versioned_class_name, Class.new(ActiveRecord::Base)).class_eval do
@@ -252,22 +229,26 @@ module ActiveRecord #:nodoc:
               find :first, :order => 'version desc',
                 :conditions => ["#{original_class.versioned_foreign_key} = ? and version < ?", version.send(original_class.versioned_foreign_key), version.version]
             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]
             end
-            
+
             def previous
               self.class.before(self)
             end
-            
+
             def next
               self.class.after(self)
             end
+
+            def versions_count
+              page.version
+            end
           end
-          
+
           versioned_class.cattr_accessor :original_class
           versioned_class.original_class = self
           versioned_class.set_table_name versioned_table_name
@@ -278,24 +259,22 @@ module ActiveRecord #:nodoc:
           versioned_class.set_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 if applicable
-        def save_version
-          save_version_on_create if save_version?
-        end
-        
+
         # Saves a version of the model in the versioned table.  This is called in the after_save callback by default
-        def save_version_on_create
-          rev = self.class.versioned_class.new
-          self.clone_versioned_model(self, rev)
-          rev.version = send(self.class.version_column)
-          rev.send("#{self.class.versioned_foreign_key}=", self.id)
-          rev.save
+        def save_version
+          if @saving_version
+            @saving_version = nil
+            rev = self.class.versioned_class.new
+            clone_versioned_model(self, rev)
+            rev.send("#{self.class.version_column}=", send(self.class.version_column))
+            rev.send("#{self.class.versioned_foreign_key}=", id)
+            rev.save
+          end
         end
  
         # Clears old revisions if a limit is set with the :limit option in <tt>acts_as_versioned</tt>.
@@ -304,24 +283,23 @@ module ActiveRecord #:nodoc:
           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
-            sql = "DELETE FROM #{self.class.versioned_table_name} WHERE version <= #{excess_baggage} AND #{self.class.versioned_foreign_key} = #{self.id}"
-            self.class.versioned_class.connection.execute sql
+            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)
-            return false unless version.send(self.class.versioned_foreign_key) == self.id and !version.new_record?
+            return false unless version.send(self.class.versioned_foreign_key) == id and !version.new_record?
           else
-            return false unless version = versions.find_by_version(version)
+            return false unless version = versions.send("find_by_#{self.class.version_column}", version)
           end
           self.clone_versioned_model(version, self)
-          self.send("#{self.class.version_column}=", version.version)
+          send("#{self.class.version_column}=", version.send(self.class.version_column))
           true
         end
  
-        # Reverts a model to a given version and saves the model.  
+        # 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
@@ -342,41 +320,29 @@ module ActiveRecord #:nodoc:
             end
           end
         end
-
-        # Returns an array of attribute keys that are versioned.  See non_versioned_columns
-        def versioned_attributes
-          self.attributes.keys.select { |k| !self.class.non_versioned_columns.include?(k) }
-        end
  
-        # If called with no parameters, gets whether the current model has changed and needs to be versioned.
-        # If called with a single parameter, gets whether the parameter has changed.
-        def changed?(attr_name = nil)
-          attr_name.nil? ?
-            (!self.class.track_changed_attributes || (changed_attributes && changed_attributes.length > 0)) :
-            (changed_attributes && changed_attributes.include?(attr_name.to_s))
+        def altered?
+          track_altered_attributes ? (version_if_changed - changed).length < version_if_changed.length : changed?
         end
-        
-        # keep old dirty? method
-        alias_method :dirty?, :changed?
-        
+
         # Clones a model.  Used when saving a new version or reverting a model's version.
         def clone_versioned_model(orig_model, new_model)
-          self.versioned_attributes.each do |key|
-            new_model.send("#{key}=", orig_model.send(key)) if orig_model.has_attribute?(key)
+          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
-          
+
           if orig_model.is_a?(self.class.versioned_class)
             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[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? && changed?
+          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?
@@ -387,7 +353,7 @@ module ActiveRecord #:nodoc:
             version_condition.call(self)
           else
             version_condition
-          end          
+          end
         end
  
         # Executes the block with the versioning callbacks disabled.
@@ -412,50 +378,24 @@ module ActiveRecord #:nodoc:
  
         def empty_callback() end #:nodoc:
  
-        protected          
+        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
-            self.send("#{self.class.version_column}=", self.next_version) if new_record? || (!locking_enabled? && save_version?)
+            @saving_version = new_record? || save_version?
+            self.send("#{self.class.version_column}=", next_version) if new_record? || (!locking_enabled? && save_version?)
           end
-          
+
           # Gets the next available version for the current record, or 1 for a new record
           def next_version
-            return 1 if new_record?
-            (versions.calculate(:max, :version) || 0) + 1
-          end
-          
-          # clears current changed attributes.  Called after save.
-          def clear_changed_attributes
-            self.changed_attributes = []
-          end
-
-          def write_changed_attribute(attr_name, attr_value)
-            # Convert to db type for comparison. Avoids failing Float<=>String comparisons.
-            attr_value_for_db = self.class.columns_hash[attr_name.to_s].type_cast(attr_value)
-            (self.changed_attributes ||= []) << attr_name.to_s unless self.changed?(attr_name) || self.send(attr_name) == attr_value_for_db
-            write_attribute(attr_name, attr_value_for_db)
+            (new_record? ? 0 : versions.calculate(:max, version_column).to_i) + 1
           end
  
         module ClassMethods
-          # Finds a specific version of a specific row of this model
-          def find_version(id, version)
-            find_versions(id, 
-              :conditions => ["#{versioned_foreign_key} = ? AND version = ?", id, version], 
-              :limit => 1).first
-          end
-        
-          # Finds versions of a specific model.  Takes an options hash like <tt>find</tt>
-          def find_versions(id, options = {})
-            versioned_class.find :all, {
-              :conditions => ["#{versioned_foreign_key} = ?", id],
-              :order      => 'version' }.merge(options)
-          end
-
           # Returns an array of columns that are versioned.  See non_versioned_columns
           def versioned_columns
-            self.columns.select { |c| !non_versioned_columns.include?(c.name) }
+            @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
@@ -464,43 +404,42 @@ module ActiveRecord #:nodoc:
           # 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| %w(version lock_version).include? c.name }
-              self.connection.add_column table_name, :version, :integer
+            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, :integer
+              t.column version_column, :integer
             end
-            
-            updated_col = nil
+
             self.versioned_columns.each do |col| 
-              updated_col = col if !updated_col && %(updated_at updated_on).include?(col.name)
               self.connection.add_column versioned_table_name, col.name, col.type, 
-                :limit => col.limit, 
-                :default => col.default,
-                :scale => col.scale,
+                :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,
+                :limit     => type_col.limit, 
+                :default   => type_col.default,
+                :scale     => type_col.scale,
                 :precision => type_col.precision
             end
-    
-            if updated_col.nil?
-              self.connection.add_column versioned_table_name, :updated_at, :timestamp
-            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
-          
+
           # Executes the block with the versioning callbacks disabled.
           #
           #   Foo.without_revision do
@@ -532,14 +471,16 @@ module ActiveRecord #:nodoc:
           def without_locking(&block)
             current = ActiveRecord::Base.lock_optimistically
             ActiveRecord::Base.lock_optimistically = false if current
-            result = block.call
-            ActiveRecord::Base.lock_optimistically = true if current
-            result
-          end          
+            begin
+              block.call
+            ensure
+              ActiveRecord::Base.lock_optimistically = true if current
+            end
+          end
         end
       end
     end
   end
 end
  
-ActiveRecord::Base.send :include, ActiveRecord::Acts::Versioned
 \ No newline at end of file
+ActiveRecord::Base.send :include, ActiveRecord::Acts::Versioned
@@ -10,11 +10,18 @@ rescue LoadError
   require 'rubygems'
   retry
 end
+
+begin
+  require 'ruby-debug'
+  Debugger.start
+rescue LoadError
+end
+
 require 'acts_as_versioned'
  
 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'] || 'sqlite']}
+ActiveRecord::Base.configurations = {'test' => config[ENV['DB'] || 'sqlite3']}
 ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
  
 load(File.dirname(__FILE__) + "/schema.rb")
@@ -3,4 +3,5 @@ washington:
     name: Washington, D.C.
     latitude: 38.895
     longitude: -77.036667
+    doesnt_trigger_version: This is not important
     version: 1
@@ -2,26 +2,26 @@ welcome_1:
   id: 1
   page_id: 1
   title: Welcome to the weblg
-  version: 23
+  lock_version: 23
   version_type: LockedPage
  
 welcome_2:
   id: 2
   page_id: 1
   title: Welcome to the weblog
-  version: 24
+  lock_version: 24
   version_type: LockedPage
  
 thinking_1:
   id: 3
   page_id: 2
   title: So I was thinking!!!
-  version: 23
+  lock_version: 23
   version_type: SpecialLockedPage
  
 thinking_2:
   id: 4
   page_id: 2
   title: So I was thinking
-  version: 24
+  lock_version: 24
   version_type: SpecialLockedPage
@@ -4,4 +4,5 @@ welcome:
   body: Such a lovely day
   version: 24
   author_id: 1
-  revisor_id: 1
 \ No newline at end of file
+  revisor_id: 1
+  created_on: "2008-01-01 00:00:00"
 \ No newline at end of file
@@ -8,10 +8,15 @@ if ActiveRecord::Base.connection.supports_migrations?
  
   class MigrationTest < Test::Unit::TestCase
     self.use_transactional_fixtures = false
-    def teardown
-      ActiveRecord::Base.connection.initialize_schema_information
-      ActiveRecord::Base.connection.update "UPDATE schema_info SET version = 0"
-
+    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
@@ -3,6 +3,7 @@ ActiveRecord::Schema.define(:version =&gt; 0) do
     t.column :version, :integer
     t.column :title, :string, :limit => 255
     t.column :body, :text
+    t.column :created_on, :datetime
     t.column :updated_on, :datetime
     t.column :author_id, :integer
     t.column :revisor_id, :integer
@@ -13,11 +14,14 @@ ActiveRecord::Schema.define(:version =&gt; 0) do
     t.column :version, :integer
     t.column :title, :string, :limit => 255
     t.column :body, :text
+    t.column :created_on, :datetime
     t.column :updated_on, :datetime
     t.column :author_id, :integer
     t.column :revisor_id, :integer
   end
  
+  add_index :page_versions, [:page_id, :version], :unique => true
+  
   create_table :authors, :force => true do |t|
     t.column :page_id, :integer
     t.column :name, :string
@@ -26,16 +30,20 @@ ActiveRecord::Schema.define(:version =&gt; 0) do
   create_table :locked_pages, :force => true do |t|
     t.column :lock_version, :integer
     t.column :title, :string, :limit => 255
+    t.column :body, :text
     t.column :type, :string, :limit => 255
   end
  
   create_table :locked_pages_revisions, :force => true do |t|
     t.column :page_id, :integer
-    t.column :version, :integer
+    t.column :lock_version, :integer
     t.column :title, :string, :limit => 255
+    t.column :body, :text
     t.column :version_type, :string, :limit => 255
     t.column :updated_at, :datetime
   end
+  
+  add_index :locked_pages_revisions, [:page_id, :lock_version], :unique => true
  
   create_table :widgets, :force => true do |t|
     t.column :name, :string, :limit => 50
@@ -51,10 +59,13 @@ ActiveRecord::Schema.define(:version =&gt; 0) do
     t.column :updated_at, :datetime
   end
  
+  add_index :widget_versions, [:widget_id, :version], :unique => true
+  
   create_table :landmarks, :force => true do |t|
     t.column :name, :string
     t.column :latitude, :float
     t.column :longitude, :float
+    t.column :doesnt_trigger_version,:string
     t.column :version, :integer
   end
  
@@ -63,6 +74,9 @@ ActiveRecord::Schema.define(:version =&gt; 0) do
     t.column :name, :string
     t.column :latitude, :float
     t.column :longitude, :float
+    t.column :doesnt_trigger_version,:string
     t.column :version, :integer
   end
+  
+  add_index :landmark_versions, [:landmark_id, :version], :unique => true
 end
@@ -17,13 +17,13 @@ class VersionedTest &lt; Test::Unit::TestCase
   def test_saves_without_revision
     p = pages(:welcome)
     old_versions = p.versions.count
-    
+
     p.save_without_revision
-    
+
     p.without_revision do
       p.update_attributes :title => 'changed'
     end
-    
+
     assert_equal old_versions, p.versions.count
   end
  
@@ -31,8 +31,8 @@ class VersionedTest &lt; Test::Unit::TestCase
     p = pages(:welcome)
     assert_equal 24, p.version
     assert_equal 'Welcome to the weblog', p.title
-    
-    assert p.revert_to!(p.versions.first.version), "Couldn't revert to 23"
+
+    assert p.revert_to!(23), "Couldn't revert to 23"
     assert_equal 23, p.version
     assert_equal 'Welcome to the weblg', p.title
   end
@@ -58,12 +58,12 @@ class VersionedTest &lt; Test::Unit::TestCase
     p = pages(:welcome)
     assert_equal 24, p.version
     assert_equal 'Welcome to the weblog', p.title
-    
-    assert p.revert_to!(p.versions.first), "Couldn't revert to 23"
+
+    assert p.revert_to!(p.versions.find_by_version(23)), "Couldn't revert to 23"
     assert_equal 23, p.version
     assert_equal 'Welcome to the weblg', p.title
   end
-  
+
   def test_rollback_fails_with_invalid_revision
     p = locked_pages(:welcome)
     assert !p.revert_to!(locked_pages(:thinking))
@@ -75,27 +75,27 @@ class VersionedTest &lt; Test::Unit::TestCase
     assert_equal 1, p.versions.size
     assert_instance_of LockedPage.versioned_class, p.versions.first
   end
-  
+
   def test_rollback_with_version_number_with_options
     p = locked_pages(:welcome)
     assert_equal 'Welcome to the weblog', p.title
     assert_equal 'LockedPage', p.versions.first.version_type
-    
-    assert p.revert_to!(p.versions.first.version), "Couldn't revert to 23"
+
+    assert p.revert_to!(p.versions.first.lock_version), "Couldn't revert to 23"
     assert_equal 'Welcome to the weblg', p.title
     assert_equal 'LockedPage', p.versions.first.version_type
   end
-  
+
   def test_rollback_with_version_class_with_options
     p = locked_pages(:welcome)
     assert_equal 'Welcome to the weblog', p.title
     assert_equal 'LockedPage', p.versions.first.version_type
-    
+
     assert p.revert_to!(p.versions.first), "Couldn't revert to 1"
     assert_equal 'Welcome to the weblg', p.title
     assert_equal 'LockedPage', p.versions.first.version_type
   end
-  
+
   def test_saves_versioned_copy_with_sti
     p = SpecialLockedPage.create! :title => 'first title'
     assert !p.new_record?
@@ -103,12 +103,12 @@ class VersionedTest &lt; Test::Unit::TestCase
     assert_instance_of LockedPage.versioned_class, p.versions.first
     assert_equal 'SpecialLockedPage', p.versions.first.version_type
   end
-  
+
   def test_rollback_with_version_number_with_sti
     p = locked_pages(:thinking)
     assert_equal 'So I was thinking', p.title
-    
-    assert p.revert_to!(p.versions.first.version), "Couldn't revert to 1"
+
+    assert p.revert_to!(p.versions.first.lock_version), "Couldn't revert to 1"
     assert_equal 'So I was thinking!!!', p.title
     assert_equal 'SpecialLockedPage', p.versions.first.version_type
   end
@@ -116,11 +116,11 @@ class VersionedTest &lt; Test::Unit::TestCase
   def test_lock_version_works_with_versioning
     p = locked_pages(:thinking)
     p2 = LockedPage.find(p.id)
-    
+
     p.title = 'fresh title'
     p.save
     assert_equal 2, p.versions.size # limit!
-    
+
     assert_raises(ActiveRecord::StaleObjectError) do
       p2.title = 'stale title'
       p2.save
@@ -130,13 +130,13 @@ class VersionedTest &lt; Test::Unit::TestCase
   def test_version_if_condition
     p = Page.create! :title => "title"
     assert_equal 1, p.version
-    
+
     Page.feeling_good = false
     p.save
     assert_equal 1, p.version
     Page.feeling_good = true
   end
-  
+
   def test_version_if_condition2
     # set new if condition
     Page.class_eval do
@@ -144,40 +144,40 @@ class VersionedTest &lt; Test::Unit::TestCase
       alias_method :old_feeling_good, :feeling_good?
       alias_method :feeling_good?, :new_feeling_good
     end
-    
+
     p = Page.create! :title => "title"
     assert_equal 1, p.version # version does not increment
-    assert_equal 1, p.versions(true).size
-    
+    assert_equal 1, p.versions.count
+
     p.update_attributes(:title => 'new title')
     assert_equal 1, p.version # version does not increment
-    assert_equal 1, p.versions(true).size
-    
+    assert_equal 1, p.versions.count
+
     p.update_attributes(:title => 'a title')
     assert_equal 2, p.version
-    assert_equal 2, p.versions(true).size
-    
+    assert_equal 2, p.versions.count
+
     # reset original if condition
     Page.class_eval { alias_method :feeling_good?, :old_feeling_good }
   end
-  
+
   def test_version_if_condition_with_block
     # set new if condition
     old_condition = Page.version_condition
     Page.version_condition = Proc.new { |page| page.title[0..0] == 'b' }
-    
+
     p = Page.create! :title => "title"
     assert_equal 1, p.version # version does not increment
-    assert_equal 1, p.versions(true).size
-    
+    assert_equal 1, p.versions.count
+
     p.update_attributes(:title => 'a title')
     assert_equal 1, p.version # version does not increment
-    assert_equal 1, p.versions(true).size
-    
+    assert_equal 1, p.versions.count
+
     p.update_attributes(:title => 'b title')
     assert_equal 2, p.version
-    assert_equal 2, p.versions(true).size
-    
+    assert_equal 2, p.versions.count
+
     # reset original if condition
     Page.version_condition = old_condition
   end
@@ -187,7 +187,10 @@ class VersionedTest &lt; Test::Unit::TestCase
     p.save
     p.save
     5.times do |i|
-      assert_page_title p, i
+      p.title = "title#{i}"
+      p.save
+      assert_equal "title#{i}", p.title
+      assert_equal (i+2), p.version
     end
   end
  
@@ -196,33 +199,31 @@ class VersionedTest &lt; Test::Unit::TestCase
     p.update_attributes(:title => "title1")
     p.update_attributes(:title => "title2")
     5.times do |i|
-      assert_page_title p, i, :lock_version
+      p.title = "title#{i}"
+      p.save
+      assert_equal "title#{i}", p.title
+      assert_equal (i+4), p.lock_version
       assert p.versions(true).size <= 2, "locked version can only store 2 versions"
     end
   end
-  
-  def test_track_changed_attributes_default_value
-    assert !Page.track_changed_attributes
-    assert LockedPage.track_changed_attributes
-    assert SpecialLockedPage.track_changed_attributes
-  end
-  
-  def test_version_order
-    assert_equal 23, pages(:welcome).versions.first.version
-    assert_equal 24, pages(:welcome).versions.last.version
+
+  def test_track_altered_attributes_default_value
+    assert !Page.track_altered_attributes
+    assert LockedPage.track_altered_attributes
+    assert SpecialLockedPage.track_altered_attributes
   end
-  
-  def test_track_changed_attributes    
+
+  def test_track_altered_attributes
     p = LockedPage.create! :title => "title"
     assert_equal 1, p.lock_version
     assert_equal 1, p.versions(true).size
-    
-    p.title = 'title'
+
+    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.versions(true).size
-    
+
     p.title = 'updated title'
     assert p.save_version?
     p.save
@@ -235,22 +236,15 @@ class VersionedTest &lt; Test::Unit::TestCase
     assert_equal 4, p.lock_version
     assert_equal 2, p.versions(true).size # version 1 deleted
   end
-    
-  def assert_page_title(p, i, version_field = :version)
-    p.title = "title#{i}"
-    p.save
-    assert_equal "title#{i}", p.title
-    assert_equal (i+4), p.send(version_field)
-  end
-  
+
   def test_find_versions
-    assert_equal 2, locked_pages(:welcome).versions.size
-    assert_equal 1, locked_pages(:welcome).versions.find(:all, :conditions => ['title LIKE ?', '%weblog%']).length
-    assert_equal 2, locked_pages(:welcome).versions.find(:all, :conditions => ['title LIKE ?', '%web%']).length
-    assert_equal 0, locked_pages(:thinking).versions.find(:all, :conditions => ['title LIKE ?', '%web%']).length
-    assert_equal 2, locked_pages(:welcome).versions.length
+    assert_equal 1, locked_pages(:welcome).versions.find(:all, :conditions => ['title LIKE ?', '%weblog%']).size
   end
-  
+
+  def test_find_version
+    assert_equal page_versions(:welcome_1), pages(:welcome).versions.find_by_version(23)
+  end
+
   def test_with_sequence
     assert_equal 'widgets_seq', Widget.versioned_class.sequence_name
     3.times { Widget.create! :name => 'new widget' }
@@ -265,25 +259,24 @@ class VersionedTest &lt; Test::Unit::TestCase
   def test_has_many_through_with_custom_association
     assert_equal [authors(:caged), authors(:mly)], pages(:welcome).revisors
   end
-  
+
   def test_referential_integrity
     pages(:welcome).destroy
     assert_equal 0, Page.count
     assert_equal 0, Page::Version.count
   end
-  
+
   def test_association_options
     association = Page.reflect_on_association(:versions)
     options = association.options
     assert_equal :delete_all, options[:dependent]
-    assert_equal 'version', options[:order]
-    
+
     association = Widget.reflect_on_association(:versions)
     options = association.options
     assert_equal :nullify, options[:dependent]
     assert_equal 'version desc', options[:order]
     assert_equal 'widget_id', options[:foreign_key]
-    
+
     widget = Widget.create! :name => 'new widget'
     assert_equal 1, Widget.count
     assert_equal 1, Widget.versioned_class.count
@@ -297,12 +290,12 @@ class VersionedTest &lt; Test::Unit::TestCase
     page_version = page.versions.last
     assert_equal page, page_version.page
   end
-  
-  def test_unchanged_attributes
+
+  def test_unaltered_attributes
     landmarks(:washington).attributes = landmarks(:washington).attributes.except("id")
     assert !landmarks(:washington).changed?
   end
-  
+
   def test_unchanged_string_attributes
     landmarks(:washington).attributes = landmarks(:washington).attributes.except("id").inject({}) { |params, (key, value)| params.update(key => value.to_s) }
     assert !landmarks(:washington).changed?
@@ -311,18 +304,67 @@ class VersionedTest &lt; Test::Unit::TestCase
   def test_should_find_earliest_version
     assert_equal page_versions(:welcome_1), pages(:welcome).versions.earliest
   end
-  
+
   def test_should_find_latest_version
     assert_equal page_versions(:welcome_2), pages(:welcome).versions.latest
   end
-  
+
   def test_should_find_previous_version
     assert_equal page_versions(:welcome_1), page_versions(:welcome_2).previous
     assert_equal page_versions(:welcome_1), pages(:welcome).versions.before(page_versions(:welcome_2))
   end
-  
+
   def test_should_find_next_version
     assert_equal page_versions(:welcome_2), page_versions(:welcome_1).next
     assert_equal page_versions(:welcome_2), pages(:welcome).versions.after(page_versions(:welcome_1))
   end
+
+  def test_should_find_version_count
+    assert_equal 2, pages(:welcome).versions.size
+  end
+
+  def test_if_changed_creates_version_if_a_listed_column_is_changed
+    landmarks(:washington).name = "Washington"
+    assert landmarks(:washington).changed?
+    assert landmarks(:washington).altered?
+  end
+
+  def test_if_changed_creates_version_if_all_listed_columns_are_changed
+    landmarks(:washington).name = "Washington"
+    landmarks(:washington).latitude = 1.0
+    landmarks(:washington).longitude = 1.0
+    assert landmarks(:washington).changed?
+    assert landmarks(:washington).altered?
+  end
+
+  def test_if_changed_does_not_create_new_version_if_unlisted_column_is_changed
+    landmarks(:washington).doesnt_trigger_version = "This should not trigger version"
+    assert landmarks(:washington).changed?
+    assert !landmarks(:washington).altered?
+  end
+
+  def test_without_locking_temporarily_disables_optimistic_locking
+    enabled1 = false
+    block_called = false
+    
+    ActiveRecord::Base.lock_optimistically = true
+    LockedPage.without_locking do
+      enabled1 = ActiveRecord::Base.lock_optimistically
+      block_called = true
+    end
+    enabled2 = ActiveRecord::Base.lock_optimistically
+    
+    assert block_called
+    assert !enabled1
+    assert enabled2
+  end
+  
+  def test_without_locking_reverts_optimistic_locking_settings_if_block_raises_exception
+    assert_raises(RuntimeError) do
+      LockedPage.without_locking do
+        raise RuntimeError, "oh noes"
+      end
+    end
+    assert ActiveRecord::Base.lock_optimistically
+  end
 end
 \ No newline at end of file
1	1	# This file is auto-generated from the current state of the database. Instead of editing this file,
2		-# please use the migrations feature of ActiveRecord to incrementally modify your database, and
	2	+# please use the migrations feature of Active Record to incrementally modify your database, and
3	3	# then regenerate this schema definition.
4	4	#
5	5	# Note that this schema.rb definition is the authoritative source for your database schema. If you need
...	...	@@ -131,8 +131,8 @@ ActiveRecord::Schema.define(:version => 69) do
131	131	t.boolean "virtual", :default => false
132	132	end
133	133
134		- add_index "categories_profiles", ["category_id"], :name => "index_categories_profiles_on_category_id"
135	134	add_index "categories_profiles", ["profile_id"], :name => "index_categories_profiles_on_profile_id"
	135	+ add_index "categories_profiles", ["category_id"], :name => "index_categories_profiles_on_category_id"
136	136
137	137	create_table "comments", :force => true do \|t\|
138	138	t.string "title"
...	...	@@ -211,8 +211,8 @@ ActiveRecord::Schema.define(:version => 69) do
211	211	t.datetime "updated_at"
212	212	end
213	213
214		- add_index "product_categorizations", ["category_id"], :name => "index_product_categorizations_on_category_id"
215	214	add_index "product_categorizations", ["product_id"], :name => "index_product_categorizations_on_product_id"
	215	+ add_index "product_categorizations", ["category_id"], :name => "index_product_categorizations_on_category_id"
216	216
217	217	create_table "products", :force => true do \|t\|
218	218	t.integer "enterprise_id"
...	...
...	...	@@ -164,7 +164,8 @@ class UserTest < Test::Unit::TestCase
164	164
165	165	def test_should_encrypt_password_with_salted_sha1
166	166	user = User.new(:login => 'lalala', :email => 'lalala@example.com', :password => 'test', :password_confirmation => 'test')
167		- user.build_person(person_data)
	167	+#TODO UPGRADE Leandro: I comment this code. The user model already create a person model
	168	+# user.build_person(person_data)
168	169	user.stubs(:salt).returns('testsalt')
169	170	user.save!
170	171
...	...	@@ -295,7 +296,8 @@ class UserTest < Test::Unit::TestCase
295	296	protected
296	297	def new_user(options = {})
297	298	user = User.new({ :login => 'quire', :email => 'quire@example.com', :password => 'quire', :password_confirmation => 'quire' }.merge(options))
298		- user.build_person(person_data)
	299	+#TODO UPGRADE Leandro: I comment this code. The user model already create a person model
	300	+# user.build_person(person_data)
299	301	user.save
300	302	user
301	303	end
...	...
1		-SVN (version numbers are overrated)
	1	+GIT (version numbers are overrated)
	2	+
	3	+* (16 Jun 2008) Backwards Compatibility is overrated (big updates for rails 2.1)
	4	+
	5	+ * Use ActiveRecord 2.1's dirty attribute checking instead [Asa Calow]
	6	+ * Remove last traces of #non_versioned_fields
	7	+ * Remove AR::Base.find_version and AR::Base.find_versions, rely on AR association proxies and named_scope
	8	+ * Remove #versions_count, rely on AR association counter caching.
	9	+ * Remove #versioned_attributes, basically the same as AR::Base.versioned_columns
2	10
3	11	* (5 Oct 2006) Allow customization of #versions association options [Dan Peterson]
4	12
...	...
1	1	require 'rubygems'
2	2
3		-Gem::manage_gems
4		-
5	3	require 'rake/rdoctask'
6	4	require 'rake/packagetask'
7	5	require 'rake/gempackagetask'
...	...
...	...	@@ -66,7 +66,7 @@ module ActiveRecord #:nodoc:
66	66	#
67	67	# See ActiveRecord::Acts::Versioned::ClassMethods#acts_as_versioned for configuration options
68	68	module Versioned
69		- CALLBACKS = [:set_new_version, :save_version_on_create, :save_version?, :clear_changed_attributes]
	69	+ CALLBACKS = [:set_new_version, :save_version, :save_version?]
70	70	def self.included(base) # :nodoc:
71	71	base.extend ClassMethods
72	72	end
...	...	@@ -95,12 +95,7 @@ module ActiveRecord #:nodoc:
95	95	# end
96	96	#
97	97	# * <tt>if_changed</tt> - Simple way of specifying attributes that are required to be changed before saving a model. This takes
98		- # either a symbol or array of symbols. WARNING - This will attempt to overwrite any attribute setters you may have.
99		- # Use this instead if you want to write your own attribute setters (and ignore if_changed):
100		- #
101		- # def name=(new_name)
102		- # write_changed_attribute :name, new_name
103		- # end
	98	+ # either a symbol or array of symbols.
104	99	#
105	100	# * <tt>extend</tt> - Lets you specify a module to be mixed in both the original and versioned models. You can also just pass a block
106	101	# to create an anonymous mixin:
...	...	@@ -148,7 +143,7 @@ module ActiveRecord #:nodoc:
148	143	# # that create_table does
149	144	# Post.create_versioned_table
150	145	# end
151		- #
	146	+ #
152	147	# def self.down
153	148	# Post.drop_versioned_table
154	149	# end
...	...	@@ -172,21 +167,10 @@ module ActiveRecord #:nodoc:
172	167	return if self.included_modules.include?(ActiveRecord::Acts::Versioned::ActMethods)
173	168
174	169	send :include, ActiveRecord::Acts::Versioned::ActMethods
175		-
176		- cattr_accessor :versioned_class_name, :versioned_foreign_key, :versioned_table_name, :versioned_inheritance_column,
177		- :version_column, :max_version_limit, :track_changed_attributes, :version_condition, :version_sequence_name, :non_versioned_columns,
178		- :version_association_options
179		-
180		- # legacy
181		- alias_method :non_versioned_fields, :non_versioned_columns
182		- alias_method :non_versioned_fields=, :non_versioned_columns=
183	170
184		- class << self
185		- alias_method :non_versioned_fields, :non_versioned_columns
186		- alias_method :non_versioned_fields=, :non_versioned_columns=
187		- end
188		-
189		- send :attr_accessor, :changed_attributes
	171	+ cattr_accessor :versioned_class_name, :versioned_foreign_key, :versioned_table_name, :versioned_inheritance_column,
	172	+ :version_column, :max_version_limit, :track_altered_attributes, :version_condition, :version_sequence_name, :non_versioned_columns,
	173	+ :version_association_options, :version_if_changed
190	174
191	175	self.versioned_class_name = options[:class_name] \|\| "Version"
192	176	self.versioned_foreign_key = options[:foreign_key] \|\| self.to_s.foreign_key
...	...	@@ -196,11 +180,10 @@ module ActiveRecord #:nodoc:
196	180	self.version_sequence_name = options[:sequence_name]
197	181	self.max_version_limit = options[:limit].to_i
198	182	self.version_condition = options[:if] \|\| true
199		- self.non_versioned_columns = [self.primary_key, inheritance_column, 'version', 'lock_version', versioned_inheritance_column]
	183	+ 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)
200	184	self.version_association_options = {
201	185	:class_name => "#{self.to_s}::#{versioned_class_name}",
202	186	:foreign_key => versioned_foreign_key,
203		- :order => 'version',
204	187	:dependent => :delete_all
205	188	}.merge(options[:association_options] \|\| {})
206	189
...	...	@@ -209,40 +192,34 @@ module ActiveRecord #:nodoc:
209	192	silence_warnings do
210	193	self.const_set(extension_module_name, Module.new(&extension))
211	194	end
212		-
	195	+
213	196	options[:extend] = self.const_get(extension_module_name)
214	197	end
215	198
216		- class_eval do
	199	+ class_eval <<-CLASS_METHODS
217	200	has_many :versions, version_association_options do
218	201	# finds earliest version of this record
219	202	def earliest
220		- @earliest \|\|= find(:first)
	203	+ @earliest \|\|= find(:first, :order => '#{version_column}')
221	204	end
222		-
	205	+
223	206	# find latest version of this record
224	207	def latest
225		- @latest \|\|= find(:first, :order => 'version desc')
	208	+ @latest \|\|= find(:first, :order => '#{version_column} desc')
226	209	end
227	210	end
228	211	before_save :set_new_version
229		- after_create :save_version_on_create
230		- after_update :save_version
	212	+ after_save :save_version
231	213	after_save :clear_old_versions
232		- after_save :clear_changed_attributes
233		-
	214	+
234	215	unless options[:if_changed].nil?
235		- self.track_changed_attributes = true
	216	+ self.track_altered_attributes = true
236	217	options[:if_changed] = [options[:if_changed]] unless options[:if_changed].is_a?(Array)
237		- options[:if_changed].each do \|attr_name\|
238		- define_method("#{attr_name}=") do \|value\|
239		- write_changed_attribute attr_name, value
240		- end
241		- end
	218	+ self.version_if_changed = options[:if_changed].map(&:to_s)
242	219	end
243		-
	220	+
244	221	include options[:extend] if options[:extend].is_a?(Module)
245		- end
	222	+ CLASS_METHODS
246	223
247	224	# create the dynamic versioned model
248	225	const_set(versioned_class_name, Class.new(ActiveRecord::Base)).class_eval do
...	...	@@ -252,22 +229,26 @@ module ActiveRecord #:nodoc:
252	229	find :first, :order => 'version desc',
253	230	:conditions => ["#{original_class.versioned_foreign_key} = ? and version < ?", version.send(original_class.versioned_foreign_key), version.version]
254	231	end
255		-
	232	+
256	233	# find first version after the given version.
257	234	def self.after(version)
258	235	find :first, :order => 'version',
259	236	:conditions => ["#{original_class.versioned_foreign_key} = ? and version > ?", version.send(original_class.versioned_foreign_key), version.version]
260	237	end
261		-
	238	+
262	239	def previous
263	240	self.class.before(self)
264	241	end
265		-
	242	+
266	243	def next
267	244	self.class.after(self)
268	245	end
	246	+
	247	+ def versions_count
	248	+ page.version
	249	+ end
269	250	end
270		-
	251	+
271	252	versioned_class.cattr_accessor :original_class
272	253	versioned_class.original_class = self
273	254	versioned_class.set_table_name versioned_table_name
...	...	@@ -278,24 +259,22 @@ module ActiveRecord #:nodoc:
278	259	versioned_class.set_sequence_name version_sequence_name if version_sequence_name
279	260	end
280	261	end
281		-
	262	+
282	263	module ActMethods
283	264	def self.included(base) # :nodoc:
284	265	base.extend ClassMethods
285	266	end
286		-
287		- # Saves a version of the model if applicable
288		- def save_version
289		- save_version_on_create if save_version?
290		- end
291		-
	267	+
292	268	# Saves a version of the model in the versioned table. This is called in the after_save callback by default
293		- def save_version_on_create
294		- rev = self.class.versioned_class.new
295		- self.clone_versioned_model(self, rev)
296		- rev.version = send(self.class.version_column)
297		- rev.send("#{self.class.versioned_foreign_key}=", self.id)
298		- rev.save
	269	+ def save_version
	270	+ if @saving_version
	271	+ @saving_version = nil
	272	+ rev = self.class.versioned_class.new
	273	+ clone_versioned_model(self, rev)
	274	+ rev.send("#{self.class.version_column}=", send(self.class.version_column))
	275	+ rev.send("#{self.class.versioned_foreign_key}=", id)
	276	+ rev.save
	277	+ end
299	278	end
300	279
301	280	# Clears old revisions if a limit is set with the :limit option in <tt>acts_as_versioned</tt>.
...	...	@@ -304,24 +283,23 @@ module ActiveRecord #:nodoc:
304	283	return if self.class.max_version_limit == 0
305	284	excess_baggage = send(self.class.version_column).to_i - self.class.max_version_limit
306	285	if excess_baggage > 0
307		- sql = "DELETE FROM #{self.class.versioned_table_name} WHERE version <= #{excess_baggage} AND #{self.class.versioned_foreign_key} = #{self.id}"
308		- self.class.versioned_class.connection.execute sql
	286	+ self.class.versioned_class.delete_all ["#{self.class.version_column} <= ? and #{self.class.versioned_foreign_key} = ?", excess_baggage, id]
309	287	end
310	288	end
311	289
312	290	# Reverts a model to a given version. Takes either a version number or an instance of the versioned model
313	291	def revert_to(version)
314	292	if version.is_a?(self.class.versioned_class)
315		- return false unless version.send(self.class.versioned_foreign_key) == self.id and !version.new_record?
	293	+ return false unless version.send(self.class.versioned_foreign_key) == id and !version.new_record?
316	294	else
317		- return false unless version = versions.find_by_version(version)
	295	+ return false unless version = versions.send("find_by_#{self.class.version_column}", version)
318	296	end
319	297	self.clone_versioned_model(version, self)
320		- self.send("#{self.class.version_column}=", version.version)
	298	+ send("#{self.class.version_column}=", version.send(self.class.version_column))
321	299	true
322	300	end
323	301
324		- # Reverts a model to a given version and saves the model.
	302	+ # Reverts a model to a given version and saves the model.
325	303	# Takes either a version number or an instance of the versioned model
326	304	def revert_to!(version)
327	305	revert_to(version) ? save_without_revision : false
...	...	@@ -342,41 +320,29 @@ module ActiveRecord #:nodoc:
342	320	end
343	321	end
344	322	end
345		-
346		- # Returns an array of attribute keys that are versioned. See non_versioned_columns
347		- def versioned_attributes
348		- self.attributes.keys.select { \|k\| !self.class.non_versioned_columns.include?(k) }
349		- end
350	323
351		- # If called with no parameters, gets whether the current model has changed and needs to be versioned.
352		- # If called with a single parameter, gets whether the parameter has changed.
353		- def changed?(attr_name = nil)
354		- attr_name.nil? ?
355		- (!self.class.track_changed_attributes \|\| (changed_attributes && changed_attributes.length > 0)) :
356		- (changed_attributes && changed_attributes.include?(attr_name.to_s))
	324	+ def altered?
	325	+ track_altered_attributes ? (version_if_changed - changed).length < version_if_changed.length : changed?
357	326	end
358		-
359		- # keep old dirty? method
360		- alias_method :dirty?, :changed?
361		-
	327	+
362	328	# Clones a model. Used when saving a new version or reverting a model's version.
363	329	def clone_versioned_model(orig_model, new_model)
364		- self.versioned_attributes.each do \|key\|
365		- new_model.send("#{key}=", orig_model.send(key)) if orig_model.has_attribute?(key)
	330	+ self.class.versioned_columns.each do \|col\|
	331	+ new_model.send("#{col.name}=", orig_model.send(col.name)) if orig_model.has_attribute?(col.name)
366	332	end
367		-
	333	+
368	334	if orig_model.is_a?(self.class.versioned_class)
369	335	new_model[new_model.class.inheritance_column] = orig_model[self.class.versioned_inheritance_column]
370	336	elsif new_model.is_a?(self.class.versioned_class)
371	337	new_model[self.class.versioned_inheritance_column] = orig_model[orig_model.class.inheritance_column]
372	338	end
373	339	end
374		-
	340	+
375	341	# Checks whether a new version shall be saved or not. Calls <tt>version_condition_met?</tt> and <tt>changed?</tt>.
376	342	def save_version?
377		- version_condition_met? && changed?
	343	+ version_condition_met? && altered?
378	344	end
379		-
	345	+
380	346	# Checks condition set in the :if option to check whether a revision should be created or not. Override this for
381	347	# custom version condition checking.
382	348	def version_condition_met?
...	...	@@ -387,7 +353,7 @@ module ActiveRecord #:nodoc:
387	353	version_condition.call(self)
388	354	else
389	355	version_condition
390		- end
	356	+ end
391	357	end
392	358
393	359	# Executes the block with the versioning callbacks disabled.
...	...	@@ -412,50 +378,24 @@ module ActiveRecord #:nodoc:
412	378
413	379	def empty_callback() end #:nodoc:
414	380
415		- protected
	381	+ protected
416	382	# sets the new version before saving, unless you're using optimistic locking. In that case, let it take care of the version.
417	383	def set_new_version
418		- self.send("#{self.class.version_column}=", self.next_version) if new_record? \|\| (!locking_enabled? && save_version?)
	384	+ @saving_version = new_record? \|\| save_version?
	385	+ self.send("#{self.class.version_column}=", next_version) if new_record? \|\| (!locking_enabled? && save_version?)
419	386	end
420		-
	387	+
421	388	# Gets the next available version for the current record, or 1 for a new record
422	389	def next_version
423		- return 1 if new_record?
424		- (versions.calculate(:max, :version) \|\| 0) + 1
425		- end
426		-
427		- # clears current changed attributes. Called after save.
428		- def clear_changed_attributes
429		- self.changed_attributes = []
430		- end
431		-
432		- def write_changed_attribute(attr_name, attr_value)
433		- # Convert to db type for comparison. Avoids failing Float<=>String comparisons.
434		- attr_value_for_db = self.class.columns_hash[attr_name.to_s].type_cast(attr_value)
435		- (self.changed_attributes \|\|= []) << attr_name.to_s unless self.changed?(attr_name) \|\| self.send(attr_name) == attr_value_for_db
436		- write_attribute(attr_name, attr_value_for_db)
	390	+ (new_record? ? 0 : versions.calculate(:max, version_column).to_i) + 1
437	391	end
438	392
439	393	module ClassMethods
440		- # Finds a specific version of a specific row of this model
441		- def find_version(id, version)
442		- find_versions(id,
443		- :conditions => ["#{versioned_foreign_key} = ? AND version = ?", id, version],
444		- :limit => 1).first
445		- end
446		-
447		- # Finds versions of a specific model. Takes an options hash like <tt>find</tt>
448		- def find_versions(id, options = {})
449		- versioned_class.find :all, {
450		- :conditions => ["#{versioned_foreign_key} = ?", id],
451		- :order => 'version' }.merge(options)
452		- end
453		-
454	394	# Returns an array of columns that are versioned. See non_versioned_columns
455	395	def versioned_columns
456		- self.columns.select { \|c\| !non_versioned_columns.include?(c.name) }
	396	+ @versioned_columns \|\|= columns.select { \|c\| !non_versioned_columns.include?(c.name) }
457	397	end
458		-
	398	+
459	399	# Returns an instance of the dynamic versioned model
460	400	def versioned_class
461	401	const_get versioned_class_name
...	...	@@ -464,43 +404,42 @@ module ActiveRecord #:nodoc:
464	404	# Rake migration task to create the versioned table using options passed to acts_as_versioned
465	405	def create_versioned_table(create_table_options = {})
466	406	# create version column in main table if it does not exist
467		- if !self.content_columns.find { \|c\| %w(version lock_version).include? c.name }
468		- self.connection.add_column table_name, :version, :integer
	407	+ if !self.content_columns.find { \|c\| [version_column.to_s, 'lock_version'].include? c.name }
	408	+ self.connection.add_column table_name, version_column, :integer
	409	+ self.reset_column_information
469	410	end
	411	+
	412	+ return if connection.table_exists?(versioned_table_name)
470	413
471	414	self.connection.create_table(versioned_table_name, create_table_options) do \|t\|
472	415	t.column versioned_foreign_key, :integer
473		- t.column :version, :integer
	416	+ t.column version_column, :integer
474	417	end
475		-
476		- updated_col = nil
	418	+
477	419	self.versioned_columns.each do \|col\|
478		- updated_col = col if !updated_col && %(updated_at updated_on).include?(col.name)
479	420	self.connection.add_column versioned_table_name, col.name, col.type,
480		- :limit => col.limit,
481		- :default => col.default,
482		- :scale => col.scale,
	421	+ :limit => col.limit,
	422	+ :default => col.default,
	423	+ :scale => col.scale,
483	424	:precision => col.precision
484	425	end
485		-
	426	+
486	427	if type_col = self.columns_hash[inheritance_column]
487	428	self.connection.add_column versioned_table_name, versioned_inheritance_column, type_col.type,
488		- :limit => type_col.limit,
489		- :default => type_col.default,
490		- :scale => type_col.scale,
	429	+ :limit => type_col.limit,
	430	+ :default => type_col.default,
	431	+ :scale => type_col.scale,
491	432	:precision => type_col.precision
492	433	end
493		-
494		- if updated_col.nil?
495		- self.connection.add_column versioned_table_name, :updated_at, :timestamp
496		- end
	434	+
	435	+ self.connection.add_index versioned_table_name, versioned_foreign_key
497	436	end
498		-
	437	+
499	438	# Rake migration task to drop the versioned table
500	439	def drop_versioned_table
501	440	self.connection.drop_table versioned_table_name
502	441	end
503		-
	442	+
504	443	# Executes the block with the versioning callbacks disabled.
505	444	#
506	445	# Foo.without_revision do
...	...	@@ -532,14 +471,16 @@ module ActiveRecord #:nodoc:
532	471	def without_locking(&block)
533	472	current = ActiveRecord::Base.lock_optimistically
534	473	ActiveRecord::Base.lock_optimistically = false if current
535		- result = block.call
536		- ActiveRecord::Base.lock_optimistically = true if current
537		- result
538		- end
	474	+ begin
	475	+ block.call
	476	+ ensure
	477	+ ActiveRecord::Base.lock_optimistically = true if current
	478	+ end
	479	+ end
539	480	end
540	481	end
541	482	end
542	483	end
543	484	end
544	485
545		-ActiveRecord::Base.send :include, ActiveRecord::Acts::Versioned
546	486	\ No newline at end of file
	487	+ActiveRecord::Base.send :include, ActiveRecord::Acts::Versioned
...	...
...	...	@@ -10,11 +10,18 @@ rescue LoadError
10	10	require 'rubygems'
11	11	retry
12	12	end
	13	+
	14	+begin
	15	+ require 'ruby-debug'
	16	+ Debugger.start
	17	+rescue LoadError
	18	+end
	19	+
13	20	require 'acts_as_versioned'
14	21
15	22	config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
16	23	ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/debug.log")
17		-ActiveRecord::Base.configurations = {'test' => config[ENV['DB'] \|\| 'sqlite']}
	24	+ActiveRecord::Base.configurations = {'test' => config[ENV['DB'] \|\| 'sqlite3']}
18	25	ActiveRecord::Base.establish_connection(ActiveRecord::Base.configurations['test'])
19	26
20	27	load(File.dirname(__FILE__) + "/schema.rb")
...	...
...	...	@@ -3,4 +3,5 @@ washington:
3	3	name: Washington, D.C.
4	4	latitude: 38.895
5	5	longitude: -77.036667
	6	+ doesnt_trigger_version: This is not important
6	7	version: 1
...	...
...	...	@@ -2,26 +2,26 @@ welcome_1:
2	2	id: 1
3	3	page_id: 1
4	4	title: Welcome to the weblg
5		- version: 23
	5	+ lock_version: 23
6	6	version_type: LockedPage
7	7
8	8	welcome_2:
9	9	id: 2
10	10	page_id: 1
11	11	title: Welcome to the weblog
12		- version: 24
	12	+ lock_version: 24
13	13	version_type: LockedPage
14	14
15	15	thinking_1:
16	16	id: 3
17	17	page_id: 2
18	18	title: So I was thinking!!!
19		- version: 23
	19	+ lock_version: 23
20	20	version_type: SpecialLockedPage
21	21
22	22	thinking_2:
23	23	id: 4
24	24	page_id: 2
25	25	title: So I was thinking
26		- version: 24
	26	+ lock_version: 24
27	27	version_type: SpecialLockedPage
...	...
...	...	@@ -4,4 +4,5 @@ welcome:
4	4	body: Such a lovely day
5	5	version: 24
6	6	author_id: 1
7		- revisor_id: 1
8	7	\ No newline at end of file
	8	+ revisor_id: 1
	9	+ created_on: "2008-01-01 00:00:00"
9	10	\ No newline at end of file
...	...
...	...	@@ -8,10 +8,15 @@ if ActiveRecord::Base.connection.supports_migrations?
8	8
9	9	class MigrationTest < Test::Unit::TestCase
10	10	self.use_transactional_fixtures = false
11		- def teardown
12		- ActiveRecord::Base.connection.initialize_schema_information
13		- ActiveRecord::Base.connection.update "UPDATE schema_info SET version = 0"
14		-
	11	+ def teardown
	12	+ if ActiveRecord::Base.connection.respond_to?(:initialize_schema_information)
	13	+ ActiveRecord::Base.connection.initialize_schema_information
	14	+ ActiveRecord::Base.connection.update "UPDATE schema_info SET version = 0"
	15	+ else
	16	+ ActiveRecord::Base.connection.initialize_schema_migrations_table
	17	+ ActiveRecord::Base.connection.assume_migrated_upto_version(0)
	18	+ end
	19	+
15	20	Thing.connection.drop_table "things" rescue nil
16	21	Thing.connection.drop_table "thing_versions" rescue nil
17	22	Thing.reset_column_information
...	...