r4663@asus: jeremy | 2006-06-19 17:23:57 -0700

 ActiveRecord::Locking is now ActiveRecord::Locking::Optimistic (to make way for Pessimistic.)


git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@4461 5ecf4fe2-1ee6-0310-87b1-e25e094e27de

2 files changed, 70 insertions, 63 deletions

diff --git a/activerecord/lib/active_record.rb b/activerecord/lib/active_record.rb
index fc70b0de68..ddd1f9ff4c 100755
--- a/activerecord/lib/active_record.rb
+++ b/activerecord/lib/active_record.rb
@@ -54,7 +54,7 @@ require 'active_record/xml_serialization'
 
 ActiveRecord::Base.class_eval do
   include ActiveRecord::Validations
-  include ActiveRecord::Locking
+  include ActiveRecord::Locking::Optimistic
   include ActiveRecord::Callbacks
   include ActiveRecord::Observing
   include ActiveRecord::Timestamp
diff --git a/activerecord/lib/active_record/locking.rb b/activerecord/lib/active_record/locking.rb
index ee4224c004..9e7564ed25 100644
--- a/activerecord/lib/active_record/locking.rb
+++ b/activerecord/lib/active_record/locking.rb
@@ -1,77 +1,84 @@
 module ActiveRecord
-  # Active Records support optimistic locking if the field <tt>lock_version</tt> is present.  Each update to the
-  # record increments the lock_version column and the locking facilities ensure that records instantiated twice
-  # will let the last one saved raise a StaleObjectError if the first was also updated. Example:
-  #
-  #   p1 = Person.find(1)
-  #   p2 = Person.find(1)
-  #   
-  #   p1.first_name = "Michael"
-  #   p1.save
-  #   
-  #   p2.first_name = "should fail"
-  #   p2.save # Raises a ActiveRecord::StaleObjectError
-  #
-  # You're then responsible for dealing with the conflict by rescuing the exception and either rolling back, merging,
-  # or otherwise apply the business logic needed to resolve the conflict.
-  #
-  # You must ensure that your database schema defaults the lock_version column to 0.
-  #
-  # This behavior can be turned off by setting <tt>ActiveRecord::Base.lock_optimistically = false</tt>.
-  # To override the name of the lock_version column, invoke the <tt>set_locking_column</tt> method.
-  # This method uses the same syntax as <tt>set_table_name</tt>
   module Locking
-    def self.included(base) #:nodoc:
-      base.class_eval do
-        alias_method_chain :update, :lock
+    # Active Records support optimistic locking if the field <tt>lock_version</tt> is present.  Each update to the
+    # record increments the lock_version column and the locking facilities ensure that records instantiated twice
+    # will let the last one saved raise a StaleObjectError if the first was also updated. Example:
+    #
+    #   p1 = Person.find(1)
+    #   p2 = Person.find(1)
+    #   
+    #   p1.first_name = "Michael"
+    #   p1.save
+    #   
+    #   p2.first_name = "should fail"
+    #   p2.save # Raises a ActiveRecord::StaleObjectError
+    #
+    # You're then responsible for dealing with the conflict by rescuing the exception and either rolling back, merging,
+    # or otherwise apply the business logic needed to resolve the conflict.
+    #
+    # You must ensure that your database schema defaults the lock_version column to 0.
+    #
+    # This behavior can be turned off by setting <tt>ActiveRecord::Base.lock_optimistically = false</tt>.
+    # To override the name of the lock_version column, invoke the <tt>set_locking_column</tt> method.
+    # This method uses the same syntax as <tt>set_table_name</tt>
+    module Optimistic
+      def self.included(base) #:nodoc:
+        super
+        base.extend ClassMethods
+
+        base.cattr_accessor :lock_optimistically
+        base.lock_optimistically = true
+
+        base.alias_method_chain :update, :lock
+        class << base
+          alias_method :locking_column=, :set_locking_column
+        end
       end
-    end
 
-    def update_with_lock #:nodoc:
-      return update_without_lock unless locking_enabled?
+      def locking_enabled? #:nodoc:
+        lock_optimistically && respond_to?(self.class.locking_column)
+      end
+
+      def update_with_lock #:nodoc:
+        return update_without_lock unless locking_enabled?
+
+        lock_col = self.class.locking_column
+        previous_value = send(lock_col)
+        send(lock_col + '=', previous_value + 1)
 
-      lock_col = self.class.locking_column
-      previous_value = send(lock_col)
-      send(lock_col + '=', previous_value + 1)
+        affected_rows = connection.update(<<-end_sql, "#{self.class.name} Update with optimistic locking")
+          UPDATE #{self.class.table_name}
+          SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))}
+          WHERE #{self.class.primary_key} = #{quote(id)} 
+          AND #{lock_col} = #{quote(previous_value)}
+        end_sql
 
-      affected_rows = connection.update(<<-end_sql, "#{self.class.name} Update with optimistic locking")
-        UPDATE #{self.class.table_name}
-        SET #{quoted_comma_pair_list(connection, attributes_with_quotes(false))}
-        WHERE #{self.class.primary_key} = #{quote(id)} 
-        AND #{lock_col} = #{quote(previous_value)}
-      end_sql
+        unless affected_rows == 1
+          raise ActiveRecord::StaleObjectError, "Attempted to update a stale object"
+        end
 
-      unless affected_rows == 1
-        raise ActiveRecord::StaleObjectError, "Attempted to update a stale object"
+        return true
       end
 
-      return true
-    end
-  end
+      module ClassMethods
+        DEFAULT_LOCKING_COLUMN = 'lock_version'
 
-  class Base
-    @@lock_optimistically = true
-    cattr_accessor :lock_optimistically
+        # Set the column to use for optimistic locking. Defaults to lock_version.
+        def set_locking_column(value = nil, &block)
+          define_attr_method :locking_column, value, &block
+          value
+        end
 
-    def locking_enabled? #:nodoc:
-      lock_optimistically && respond_to?(self.class.locking_column)
-    end
-    
-    class << self
-      def set_locking_column(value = nil, &block)
-        define_attr_method :locking_column, value, &block
-      end
-  
-      def locking_column #:nodoc:
-        reset_locking_column
-      end
-  
-      def reset_locking_column #:nodoc:
-        default = 'lock_version'
-        set_locking_column(default)
-        default
+        # The version column used for optimistic locking. Defaults to lock_version.
+        def locking_column
+          reset_locking_column
+        end
+
+        # Reset the column used for optimistic locking back to the lock_version default.
+        def reset_locking_column
+          set_locking_column DEFAULT_LOCKING_COLUMN
+        end
       end
     end
-    
   end
 end