activerecord 1.14.4 → 1.15.0

data/lib/active_record/deprecated_associations.rb

@@ -4,65 +4,77 @@ module ActiveRecord
       def deprecated_collection_count_method(collection_name)# :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
           def #{collection_name}_count(force_reload = false)
+            unless has_attribute?(:#{collection_name}_count)
+              ActiveSupport::Deprecation.warn :#{collection_name}_count
+            end
             #{collection_name}.reload if force_reload
             #{collection_name}.size
           end
         end_eval
       end
-      
+
       def deprecated_add_association_relation(association_name)# :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
           def add_#{association_name}(*items)
             #{association_name}.concat(items)
           end
+          deprecate :add_#{association_name} => "use #{association_name}.concat instead"
         end_eval
       end
-    
+
       def deprecated_remove_association_relation(association_name)# :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
           def remove_#{association_name}(*items)
             #{association_name}.delete(items)
           end
+          deprecate :remove_#{association_name} => "use #{association_name}.delete instead"
         end_eval
       end
-    
+
       def deprecated_has_collection_method(collection_name)# :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
           def has_#{collection_name}?(force_reload = false)
             !#{collection_name}(force_reload).empty?
           end
+          deprecate :has_#{collection_name}? => "use !#{collection_name}.empty? instead"
         end_eval
       end
-      
+
       def deprecated_find_in_collection_method(collection_name)# :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
           def find_in_#{collection_name}(association_id)
             #{collection_name}.find(association_id)
           end
+          deprecate :find_in_#{collection_name} => "use #{collection_name}.find instead"
         end_eval
       end
-      
+
       def deprecated_find_all_in_collection_method(collection_name)# :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
           def find_all_in_#{collection_name}(runtime_conditions = nil, orderings = nil, limit = nil, joins = nil)
-            #{collection_name}.find_all(runtime_conditions, orderings, limit, joins)
+            ActiveSupport::Deprecation.silence do
+              #{collection_name}.find_all(runtime_conditions, orderings, limit, joins)
+            end
           end
+          deprecate :find_all_in_#{collection_name} => "use #{collection_name}.find(:all, ...) instead"
         end_eval
       end
-    
+
       def deprecated_collection_create_method(collection_name)# :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
           def create_in_#{collection_name}(attributes = {})
             #{collection_name}.create(attributes)
           end
+          deprecate :create_in_#{collection_name} => "use #{collection_name}.create instead"
         end_eval
       end
-    
+
       def deprecated_collection_build_method(collection_name)# :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
           def build_to_#{collection_name}(attributes = {})
             #{collection_name}.build(attributes)
           end
+          deprecate :build_to_#{collection_name} => "use #{collection_name}.build instead"
         end_eval
       end
 
@@ -75,16 +87,18 @@ module ActiveRecord
               raise "Comparison object is a #{association_class_name}, should have been \#{comparison_object.class.name}"
             end
           end
+          deprecate :#{association_name}? => :==
         end_eval
       end
-        
+
       def deprecated_has_association_method(association_name) # :nodoc:
         module_eval <<-"end_eval", __FILE__, __LINE__
           def has_#{association_name}?(force_reload = false)
             !#{association_name}(force_reload).nil?
           end
+          deprecate :has_#{association_name}? => "use !#{association_name} insead"
         end_eval
-      end      
+      end
     end
   end
 end

data/lib/active_record/deprecated_finders.rb

@@ -10,6 +10,7 @@ module ActiveRecord
       def find_on_conditions(ids, conditions) # :nodoc:
         find(ids, :conditions => conditions)
       end
+      deprecate :find_on_conditions => "use find(ids, :conditions => conditions)"
 
       # This method is deprecated in favor of find(:first, options).
       #
@@ -21,6 +22,7 @@ module ActiveRecord
       def find_first(conditions = nil, orderings = nil, joins = nil) # :nodoc:
         find(:first, :conditions => conditions, :order => orderings, :joins => joins)
       end
+      deprecate :find_first => "use find(:first, ...)"
 
       # This method is deprecated in favor of find(:all, options).
       #
@@ -36,6 +38,7 @@ module ActiveRecord
         limit, offset = limit.is_a?(Array) ? limit : [ limit, nil ]
         find(:all, :conditions => conditions, :order => orderings, :joins => joins, :limit => limit, :offset => offset)
       end
+      deprecate :find_all => "use find(:all, ...)"
     end
   end
-end
+end

data/lib/active_record/fixtures.rb

@@ -252,7 +252,7 @@ class Fixtures < YAML::Omap
       end               
       all_loaded_fixtures.merge! fixtures_map  
 
-      connection.transaction do
+      connection.transaction(Thread.current['open_transactions'] == 0) do
         fixtures.reverse.each { |fixture| fixture.delete_existing_fixtures }
         fixtures.each { |fixture| fixture.insert_fixtures }
 
@@ -294,21 +294,24 @@ class Fixtures < YAML::Omap
     def read_fixture_files
       if File.file?(yaml_file_path)
         # YAML fixtures
+        yaml_string = ""
+        Dir["#{@fixture_path}/**/*.yml"].select {|f| test(?f,f) }.each do |subfixture_path|
+          yaml_string << IO.read(subfixture_path)
+        end
+        yaml_string << IO.read(yaml_file_path)
         begin
-          yaml_string = ""
-          Dir["#{@fixture_path}/**/*.yml"].select {|f| test(?f,f) }.each do |subfixture_path|
-            yaml_string << IO.read(subfixture_path)
-          end
-          yaml_string << IO.read(yaml_file_path)
-
-          if yaml = YAML::load(erb_render(yaml_string))
-            yaml = yaml.value if yaml.respond_to?(:type_id) and yaml.respond_to?(:value)
-            yaml.each do |name, data|
-              self[name] = Fixture.new(data, @class_name)
+          yaml = YAML::load(erb_render(yaml_string))
+        rescue Exception=>boom
+          raise Fixture::FormatError, "a YAML error occurred parsing #{yaml_file_path}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{boom.class}: #{boom}"
+        end         
+        if yaml
+          yaml = yaml.value if yaml.respond_to?(:type_id) and yaml.respond_to?(:value)
+          yaml.each do |name, data|
+            unless data
+              raise Fixture::FormatError, "Bad data for #{@class_name} fixture named #{name} (nil)"
             end
+            self[name] = Fixture.new(data, @class_name)
           end
-        rescue Exception=>boom
-          raise Fixture::FormatError, "a YAML error occured parsing #{yaml_file_path}. Please note that YAML must be consistently indented using spaces. Tabs are not allowed. Please have a look at http://www.yaml.org/faq.html\nThe exact error was:\n  #{boom.class}: #{boom}"
         end
       elsif File.file?(csv_file_path)
         # CSV fixtures
@@ -368,7 +371,7 @@ class Fixture #:nodoc:
       when String
         @fixture = read_fixture_file(fixture)
       else
-        raise ArgumentError, "Bad fixture argument #{fixture.inspect}"
+        raise ArgumentError, "Bad fixture argument #{fixture.inspect} during creation of #{class_name} fixture"
     end
 
     @class_name = class_name
@@ -392,7 +395,13 @@ class Fixture #:nodoc:
   end
 
   def value_list
-    @fixture.values.map { |v| ActiveRecord::Base.connection.quote(v).gsub('\\n', "\n").gsub('\\r', "\r") }.join(", ")
+    klass = @class_name.constantize rescue nil
+
+    list = @fixture.inject([]) do |fixtures, (key, value)|
+      col = klass.columns_hash[key] if klass.kind_of?(ActiveRecord::Base)
+      fixtures << ActiveRecord::Base.connection.quote(value, col).gsub('[^\]\\n', "\n").gsub('[^\]\\r', "\r")
+    end
+    list * ', '
   end
 
   def find
@@ -460,7 +469,7 @@ module Test #:nodoc:
           file_name = table_name.to_s
           file_name = file_name.singularize if ActiveRecord::Base.pluralize_table_names
           begin
-            require file_name
+            require_dependency file_name
           rescue LoadError
             # Let's hope the developer has included it himself
           end
@@ -484,12 +493,13 @@ module Test #:nodoc:
       end
 
       def self.uses_transaction(*methods)
-        @uses_transaction ||= []
-        @uses_transaction.concat methods.map { |m| m.to_s }
+        @uses_transaction = [] unless defined?(@uses_transaction)
+        @uses_transaction.concat methods.map(&:to_s)
       end
 
       def self.uses_transaction?(method)
-        @uses_transaction && @uses_transaction.include?(method.to_s)
+        @uses_transaction = [] unless defined?(@uses_transaction)
+        @uses_transaction.include?(method.to_s)
       end
 
       def use_transactional_fixtures?
@@ -498,6 +508,8 @@ module Test #:nodoc:
       end
 
       def setup_with_fixtures
+        return unless defined?(ActiveRecord::Base) && !ActiveRecord::Base.configurations.blank?
+
         if pre_loaded_fixtures && !use_transactional_fixtures
           raise RuntimeError, 'pre_loaded_fixtures requires use_transactional_fixtures' 
         end
@@ -512,7 +524,7 @@ module Test #:nodoc:
             load_fixtures
             @@already_loaded_fixtures[self.class] = @loaded_fixtures
           end
-          ActiveRecord::Base.lock_mutex
+          ActiveRecord::Base.send :increment_open_transactions
           ActiveRecord::Base.connection.begin_db_transaction
 
         # Load fixtures for every test.
@@ -528,10 +540,12 @@ module Test #:nodoc:
       alias_method :setup, :setup_with_fixtures
 
       def teardown_with_fixtures
-        # Rollback changes.
-        if use_transactional_fixtures?
+        return unless defined?(ActiveRecord::Base) && !ActiveRecord::Base.configurations.blank?
+
+        # Rollback changes if a transaction is active.
+        if use_transactional_fixtures? && Thread.current['open_transactions'] != 0
           ActiveRecord::Base.connection.rollback_db_transaction
-          ActiveRecord::Base.unlock_mutex
+          Thread.current['open_transactions'] = 0
         end
         ActiveRecord::Base.verify_active_connections!
       end

data/lib/active_record/locking/optimistic.rb

@@ -0,0 +1,106 @@
+module ActiveRecord
+  module Locking
+    # 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
+        base.alias_method_chain :attributes_from_column_definition, :lock
+        
+        class << base
+          alias_method :locking_column=, :set_locking_column
+        end
+      end
+
+      def locking_enabled? #:nodoc:
+        lock_optimistically && respond_to?(self.class.locking_column)
+      end
+
+      def attributes_from_column_definition_with_lock
+        result = attributes_from_column_definition_without_lock
+        
+        # If the locking column has no default value set,
+        # start the lock version at zero.  Note we can't use
+        # locking_enabled? at this point as @attributes may
+        # not have been initialized yet
+        
+        if lock_optimistically && result.include?(self.class.locking_column)
+          result[self.class.locking_column] ||= 0
+        end
+        
+        return result
+      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)
+
+        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_value(id)}
+          AND #{self.class.quoted_locking_column} = #{quote_value(previous_value)}
+        end_sql
+
+        unless affected_rows == 1
+          raise ActiveRecord::StaleObjectError, "Attempted to update a stale object"
+        end
+
+        return true
+      end
+
+      module ClassMethods
+        DEFAULT_LOCKING_COLUMN = 'lock_version'
+
+        # 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
+
+        # The version column used for optimistic locking. Defaults to lock_version.
+        def locking_column
+          reset_locking_column
+        end
+
+        # Quote the column name used for optimistic locking.
+        def quoted_locking_column
+          connection.quote_column_name(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

data/lib/active_record/locking/pessimistic.rb

@@ -0,0 +1,77 @@
+# Copyright (c) 2006 Shugo Maeda <shugo@ruby-lang.org>
+#
+# Permission is hereby granted, free of charge, to any person obtaining
+# a copy of this software and associated documentation files (the
+# "Software"), to deal in the Software without restriction, including
+# without limitation the rights to use, copy, modify, merge, publish,
+# distribute, sublicense, and/or sell copies of the Software, and to
+# permit persons to whom the Software is furnished to do so, subject
+# to the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+# IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR
+# ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF
+# CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+# WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+
+module ActiveRecord
+  module Locking
+    # Locking::Pessimistic provides support for row-level locking using
+    # SELECT ... FOR UPDATE and other lock types.
+    #
+    # Pass :lock => true to ActiveRecord::Base.find to obtain an exclusive
+    # lock on the selected rows:
+    #   # select * from accounts where id=1 for update
+    #   Account.find(1, :lock => true)
+    #
+    # Pass :lock => 'some locking clause' to give a database-specific locking clause
+    # of your own such as 'LOCK IN SHARE MODE' or 'FOR UPDATE NOWAIT'.
+    #
+    # Example:
+    #   Account.transaction do
+    #     # select * from accounts where name = 'shugo' limit 1 for update
+    #     shugo = Account.find(:first, :conditions => "name = 'shugo'", :lock => true)
+    #     yuko = Account.find(:first, :conditions => "name = 'yuko'", :lock => true)
+    #     shugo.balance -= 100
+    #     shugo.save!
+    #     yuko.balance += 100
+    #     yuko.save!
+    #   end
+    #
+    # You can also use ActiveRecord::Base#lock! method to lock one record by id.
+    # This may be better if you don't need to lock every row. Example:
+    #   Account.transaction do
+    #     # select * from accounts where ...
+    #     accounts = Account.find(:all, :conditions => ...)
+    #     account1 = accounts.detect { |account| ... }
+    #     account2 = accounts.detect { |account| ... }
+    #     # select * from accounts where id=? for update
+    #     account1.lock!
+    #     account2.lock!
+    #     account1.balance -= 100
+    #     account1.save!
+    #     account2.balance += 100
+    #     account2.save!
+    #   end
+    #
+    # Database-specific information on row locking:
+    #   MySQL: http://dev.mysql.com/doc/refman/5.1/en/innodb-locking-reads.html
+    #   PostgreSQL: http://www.postgresql.org/docs/8.1/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
+    module Pessimistic
+      # Obtain a row lock on this record. Reloads the record to obtain the requested
+      # lock. Pass an SQL locking clause to append the end of the SELECT statement
+      # or pass true for "FOR UPDATE" (the default, an exclusive row lock).  Returns
+      # the locked record.
+      def lock!(lock = true)
+        reload(:lock => lock) unless new_record?
+        self
+      end
+    end
+  end
+end

data/lib/active_record/migration.rb

@@ -64,8 +64,10 @@ module ActiveRecord
   # * <tt>rename_table(old_name, new_name)</tt>: Renames the table called +old_name+ to +new_name+.
   # * <tt>add_column(table_name, column_name, type, options)</tt>: Adds a new column to the table called +table_name+
   #   named +column_name+ specified to be one of the following types:
-  #   :string, :text, :integer, :float, :datetime, :timestamp, :time, :date, :binary, :boolean. A default value can be specified
-  #   by passing an +options+ hash like { :default => 11 }.
+  #   :string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time,
+  #   :date, :binary, :boolean. A default value can be specified by passing an
+  #   +options+ hash like { :default => 11 }. Other options include :limit and :null (e.g. { :limit => 50, :null => false })
+  #   -- see ActiveRecord::ConnectionAdapters::TableDefinition#column for details.
   # * <tt>rename_column(table_name, column_name, new_column_name)</tt>: Renames a column but keeps the type and content.
   # * <tt>change_column(table_name, column_name, type, options)</tt>:  Changes the column to a different type using the same
   #   parameters as add_column.
@@ -156,7 +158,7 @@ module ActiveRecord
   #       add_column :people, :salary, :integer
   #       Person.reset_column_information
   #       Person.find(:all).each do |p|
-  #         p.salary = SalaryCalculator.compute(p)
+  #         p.update_attribute :salary, SalaryCalculator.compute(p)
   #       end
   #     end
   #   end
@@ -176,7 +178,7 @@ module ActiveRecord
   #     ...
   #     say_with_time "Updating salaries..." do
   #       Person.find(:all).each do |p|
-  #         p.salary = SalaryCalculator.compute(p)
+  #         p.update_attribute :salary, SalaryCalculator.compute(p)
   #       end
   #     end
   #     ...
@@ -381,7 +383,8 @@ module ActiveRecord
       end
       
       def reached_target_version?(version)
-        (up? && version.to_i - 1 == @target_version) || (down? && version.to_i == @target_version)
+        return false if @target_version == nil
+        (up? && version.to_i - 1 >= @target_version) || (down? && version.to_i <= @target_version)
       end
       
       def irrelevant_migration?(version)