activerecord 1.3.0 → 1.4.0

data/CHANGELOG

@@ -1,4 +1,79 @@
-*1.3.0*
+*1.4.0* (January 4th, 2005)
+
+* Added automated 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.
+
+  #384 [Michael Koziarski]
+
+* Added dynamic attribute-based finders as a cleaner way of getting objects by simple queries without turning to SQL. 
+  They work by appending the name of an attribute to <tt>find_by_</tt>, so you get finders like <tt>Person.find_by_user_name,
+  Payment.find_by_transaction_id</tt>. So instead of writing <tt>Person.find_first(["user_name = ?", user_name])</tt>, you just do
+  <tt>Person.find_by_user_name(user_name)</tt>.
+  
+  It's also possible to use multiple attributes in the same find by separating them with "_and_", so you get finders like
+  <tt>Person.find_by_user_name_and_password</tt> or even <tt>Payment.find_by_purchaser_and_state_and_country</tt>. So instead of writing
+  <tt>Person.find_first(["user_name = ? AND password = ?", user_name, password])</tt>, you just do 
+  <tt>Person.find_by_user_name_and_password(user_name, password)</tt>.
+
+  While primarily a construct for easier find_firsts, it can also be used as a construct for find_all by using calls like 
+  <tt>Payment.find_all_by_amount(50)</tt> that is turned into <tt>Payment.find_all(["amount = ?", 50])</tt>. This is something not as equally useful,
+  though, as it's not possible to specify the order in which the objects are returned.
+
+* Added block-style for callbacks #332 [bitsweat].
+
+    Before:
+      before_destroy(Proc.new{ |record| Person.destroy_all "firm_id = #{record.id}" })
+    
+    After:
+      before_destroy { |record| Person.destroy_all "firm_id = #{record.id}" }
+
+* Added :counter_cache option to acts_as_tree that works just like the one you can define on belongs_to #371 [Josh]
+
+* Added Base.default_timezone accessor that determines whether to use Time.local (using :local) or Time.utc (using :utc) when pulling dates 
+  and times from the database. This is set to :local by default.
+
+* Added the possibility for adapters to overwrite add_limit! to implement a different limiting scheme than "LIMIT X" used by MySQL, PostgreSQL, and SQLite.
+
+* Added the possibility of having objects with acts_as_list created before their scope is available or...
+
+* Added a db2 adapter that only depends on the Ruby/DB2 bindings (http://raa.ruby-lang.org/project/ruby-db2/) #386 [Maik Schmidt]
+
+* Added the final touches to the Microsoft SQL Server adapter by Joey Gibson that makes it suitable for actual use #394 [DeLynn Barry]
+
+* Added that Base#find takes an optional options hash, including :conditions. Base#find_on_conditions deprecated in favor of #find with :conditions #407 [bitsweat]
+
+* Added HasManyAssociation#count that works like Base#count #413 [intinig]
+
+* Fixed handling of binary content in blobs and similar fields for Ruby/MySQL and SQLite #409 [xal]
+
+* Fixed a bug in the Ruby/MySQL that caused binary content to be escaped badly and come back mangled #405 [Tobias Luetke]
+
+* Fixed that the const_missing autoload assumes the requested constant is set by require_association and calls const_get to retrieve it. 
+  If require_association did not set the constant then const_get will call const_missing, resulting in an infinite loop #380 [bitsweat]
+
+* Fixed broken transactions that were actually only running object-level and not db level transactions [andreas]
+
+* Fixed that validates_uniqueness_of used 'id' instead of defined primary key #406
+
+* Fixed that the overwritten respond_to? method didn't take two parameters like the original #391
+
+* Fixed quoting in validates_format_of that would allow some rules to pass regardless of input #390 [Dmitry V. Sabanin]
+
+
+*1.3.0* (December 23, 2004)
 
 * Added a require_association hook on const_missing that makes it possible to use any model class without requiring it first. This makes STI look like:
 
@@ -638,7 +713,7 @@
 * Fixed PostgreSQL adapter so default values are displayed properly when used in conjunction with 
   Action Pack scaffolding.
 
-* Fixed booleans support for PostgreSQL (use real true/false�on boolean fields instead of 0/1 on tinyints) [radsaq]
+* Fixed booleans support for PostgreSQL (use real true/false on boolean fields instead of 0/1 on tinyints) [radsaq]
 
 
 *0.9.2*

data/install.rb

@@ -35,11 +35,14 @@ files = %w-
  active_record/base.rb
  active_record/callbacks.rb
  active_record/connection_adapters/abstract_adapter.rb
+ active_record/connection_adapters/db2_adapter.rb
  active_record/connection_adapters/mysql_adapter.rb
  active_record/connection_adapters/postgresql_adapter.rb
  active_record/connection_adapters/sqlite_adapter.rb
+ active_record/connection_adapters/sqlserver_adapter.rb
  active_record/deprecated_associations.rb
  active_record/fixtures.rb
+ active_record/locking.rb
  active_record/observer.rb
  active_record/reflection.rb
  active_record/acts/list.rb
@@ -48,6 +51,8 @@ files = %w-
  active_record/support/class_inheritable_attributes.rb
  active_record/support/clean_logger.rb
  active_record/support/inflector.rb
+ active_record/support/misc.rb
+ active_record/timestamp.rb
  active_record/transactions.rb
  active_record/validations.rb
  active_record/vendor/mysql.rb

data/lib/active_record.rb

@@ -26,6 +26,7 @@ $:.unshift(File.dirname(__FILE__))
 
 require 'active_record/support/clean_logger'
 require 'active_record/support/misc'
+require 'active_record/support/dependencies'
 
 require 'active_record/base'
 require 'active_record/observer'
@@ -38,11 +39,13 @@ require 'active_record/reflection'
 require 'active_record/timestamp'
 require 'active_record/acts/list'
 require 'active_record/acts/tree'
+require 'active_record/locking'
 
 ActiveRecord::Base.class_eval do
   include ActiveRecord::Validations
-  include ActiveRecord::Timestamp
   include ActiveRecord::Callbacks
+  include ActiveRecord::Locking
+  include ActiveRecord::Timestamp
   include ActiveRecord::Associations
   include ActiveRecord::Aggregations
   include ActiveRecord::Transactions
@@ -54,4 +57,5 @@ end
 require 'active_record/connection_adapters/mysql_adapter'
 require 'active_record/connection_adapters/postgresql_adapter'
 require 'active_record/connection_adapters/sqlite_adapter'
-require 'active_record/connection_adapters/sqlserver_adapter'
+require 'active_record/connection_adapters/sqlserver_adapter'
+require 'active_record/connection_adapters/db2_adapter'

data/lib/active_record/acts/list.rb

@@ -36,19 +36,31 @@ module ActiveRecord
 
           configuration[:scope] = "#{configuration[:scope]}_id".intern if configuration[:scope].is_a?(Symbol) && configuration[:scope].to_s !~ /_id$/
           
+          if configuration[:scope].is_a?(Symbol)
+            scope_condition_method = %(
+              def scope_condition
+                if #{configuration[:scope].to_s}.nil?
+                  "#{configuration[:scope].to_s} IS NULL"
+                else
+                  "#{configuration[:scope].to_s} = \#{#{configuration[:scope].to_s}}"
+                end
+              end
+            )
+          else
+            scope_condition_method = "def scope_condition() \"#{configuration[:scope]}\" end"
+          end
+          
           class_eval <<-EOV
             include ActiveRecord::Acts::List::InstanceMethods
 
             def position_column
               '#{configuration[:column]}'
             end
-
-            def scope_condition
-              "#{configuration[:scope].is_a?(Symbol) ? configuration[:scope].to_s + " = \#{" + configuration[:scope].to_s + "}" : configuration[:scope]}"
-            end
+            
+            #{scope_condition_method}
             
             before_destroy :remove_from_list
-            before_create   :add_to_list_bottom
+            before_create  :add_to_list_bottom
           EOV
         end
       end
@@ -123,55 +135,54 @@ module ActiveRecord
         end
 
         private
-        
-        def add_to_list_top
-          increment_positions_on_all_items
-        end
+          def add_to_list_top
+            increment_positions_on_all_items
+          end
 
-        def add_to_list_bottom
-          write_attribute(position_column, bottom_position_in_list.to_i + 1)
-        end
+          def add_to_list_bottom
+            write_attribute(position_column, bottom_position_in_list.to_i + 1)
+          end
       
-        # Overwrite this method to define the scope of the list changes
-        def scope_condition() "1" end
+          # Overwrite this method to define the scope of the list changes
+          def scope_condition() "1" end
 
-        def bottom_position_in_list
-          item = bottom_item
-          item ? item.send(position_column) : 0
-        end
+          def bottom_position_in_list
+            item = bottom_item
+            item ? item.send(position_column) : 0
+          end
 
-        def bottom_item
-          self.class.find_first(
-            "#{scope_condition} ",
-            "#{position_column} DESC"
-          )
-        end
+          def bottom_item
+            self.class.find_first(
+              "#{scope_condition} ",
+              "#{position_column} DESC"
+            )
+          end
 
-        def assume_bottom_position
-          update_attribute position_column, bottom_position_in_list.to_i + 1
-        end
+          def assume_bottom_position
+            update_attribute position_column, bottom_position_in_list.to_i + 1
+          end
   
-        def assume_top_position
-          update_attribute position_column, 1
-        end
+          def assume_top_position
+            update_attribute position_column, 1
+          end
   
-        def decrement_positions_on_lower_items
-          self.class.update_all(
-            "#{position_column} = (#{position_column} - 1)",  "#{scope_condition} AND #{position_column} > #{send(position_column).to_i}"
-          )
-        end
+          def decrement_positions_on_lower_items
+            self.class.update_all(
+              "#{position_column} = (#{position_column} - 1)",  "#{scope_condition} AND #{position_column} > #{send(position_column).to_i}"
+            )
+          end
   
-        def increment_positions_on_higher_items
-          self.class.update_all(
-            "#{position_column} = (#{position_column} + 1)",  "#{scope_condition} AND #{position_column} < #{send(position_column).to_i}"
-          )
-        end
+          def increment_positions_on_higher_items
+            self.class.update_all(
+              "#{position_column} = (#{position_column} + 1)",  "#{scope_condition} AND #{position_column} < #{send(position_column).to_i}"
+            )
+          end
 
-        def increment_positions_on_all_items
-          self.class.update_all(
-            "#{position_column} = (#{position_column} + 1)",  "#{scope_condition}"
-          )
-        end
+          def increment_positions_on_all_items
+            self.class.update_all(
+              "#{position_column} = (#{position_column} + 1)",  "#{scope_condition}"
+            )
+          end
       end     
     end
   end

data/lib/active_record/acts/tree.rb

@@ -31,11 +31,12 @@ module ActiveRecord
         #
         # * <tt>foreign_key</tt> - specifies the column name to use for track of the tree (default: parent_id)
         # * <tt>order</tt> - makes it possible to sort the children according to this SQL snippet.
+        # * <tt>counter_cache</tt> - keeps a count in a children_count column if set to true (default: false).
         def acts_as_tree(options = {})
-          configuration = { :foreign_key => "parent_id", :order => nil }
+          configuration = { :foreign_key => "parent_id", :order => nil, :counter_cache => nil }
           configuration.update(options) if options.is_a?(Hash)
           
-          belongs_to :parent, :class_name => name, :foreign_key => configuration[:foreign_key]
+          belongs_to :parent, :class_name => name, :foreign_key => configuration[:foreign_key], :counter_cache => configuration[:counter_cache]
           has_many :children, :class_name => name, :foreign_key => configuration[:foreign_key], :order => configuration[:order], :dependent => true
         end
       end

data/lib/active_record/associations.rb

@@ -3,30 +3,6 @@ require 'active_record/associations/has_many_association'
 require 'active_record/associations/has_and_belongs_to_many_association'
 require 'active_record/deprecated_associations'
 
-
-unless Object.respond_to?(:require_association)
-  Object.send(:define_method, :require_association) { |file_name| ActiveRecord::Base.require_association(file_name) }
-end
-
-class Object
-  class << self
-    # Use const_missing to autoload associations so we don't have to
-    # require_association when using single-table inheritance.
-    unless respond_to?(:pre_association_const_missing)
-      alias_method :pre_association_const_missing, :const_missing
-
-      def const_missing(class_id)
-        begin
-          require_association(Inflector.underscore(Inflector.demodulize(class_id.to_s)))
-          return Object.const_get(class_id) if Object.const_get(class_id).ancestors.include?(ActiveRecord::Base)
-        rescue LoadError
-          pre_association_const_missing(class_id)
-        end
-      end
-    end
-  end
-end
-
 module ActiveRecord
   module Associations # :nodoc:
     def self.append_features(base)
@@ -146,7 +122,7 @@ module ActiveRecord
     # All of the association macros can be specialized through options which makes more complex cases than the simple and guessable ones
     # possible.
     module ClassMethods
-      # Adds the following methods for retrival and query of collections of associated objects.
+      # Adds the following methods for retrieval and query of collections of associated objects.
       # +collection+ is replaced with the symbol passed as the first argument, so 
       # <tt>has_many :clients</tt> would add among others <tt>has_clients?</tt>.
       # * <tt>collection(force_reload = false)</tt> - returns an array of all the associated objects.
@@ -248,7 +224,7 @@ module ActiveRecord
         deprecated_build_method(association_name)
       end
 
-      # Adds the following methods for retrival and query of a single associated object.
+      # Adds the following methods for retrieval and query of a single associated object.
       # +association+ is replaced with the symbol passed as the first argument, so 
       # <tt>has_one :manager</tt> would add among others <tt>has_manager?</tt>.
       # * <tt>association(force_reload = false)</tt> - returns the associated object. Nil is returned if none is found.
@@ -304,7 +280,7 @@ module ActiveRecord
         module_eval "before_destroy '#{association_name}.destroy if has_#{association_name}?'" if options[:dependent]
       end
 
-      # Adds the following methods for retrival and query for a single associated object that this object holds an id to.
+      # Adds the following methods for retrieval and query for a single associated object that this object holds an id to.
       # +association+ is replaced with the symbol passed as the first argument, so 
       # <tt>belongs_to :author</tt> would add among others <tt>has_author?</tt>.
       # * <tt>association(force_reload = false)</tt> - returns the associated object. Nil is returned if none is found.
@@ -313,7 +289,7 @@ module ActiveRecord
       #   same id as the associated object.
       # * <tt>association.nil?</tt> - returns true if there is no associated object.
       #
-      # Example: An Post class declares <tt>has_one :author</tt>, which will add:
+      # Example: A Post class declares <tt>has_one :author</tt>, which will add:
       # * <tt>Post#author</tt> (similar to <tt>Author.find(author_id)</tt>)
       # * <tt>Post#author=(author)</tt> (similar to <tt>post.author_id = author.id</tt>)
       # * <tt>Post#author?</tt> (similar to <tt>post.author == some_author</tt>)
@@ -388,9 +364,12 @@ module ActiveRecord
       #
       # Any additional fields added to the join table will be placed as attributes when pulling records out through
       # has_and_belongs_to_many associations. This is helpful when have information about the association itself
-      # that you want available on retrival.
+      # that you want available on retrieval. Note that any fields in the join table will override matching field names
+      # in the two joined tables. As a consequence, having an "id" field in the join table usually has the undesirable
+      # result of clobbering the "id" fields in either of the other two tables.
+      # 
       #
-      # Adds the following methods for retrival and query.
+      # Adds the following methods for retrieval and query.
       # +collection+ is replaced with the symbol passed as the first argument, so 
       # <tt>has_and_belongs_to_many :categories</tt> would add among others +add_categories+.
       # * <tt>collection(force_reload = false)</tt> - returns an array of all the associated objects.
@@ -478,31 +457,6 @@ module ActiveRecord
         deprecated_has_collection_method(association_name)
       end
 
-      # Loads the <tt>file_name</tt> if reload_associations is true or requires if it's false.
-      def require_association(file_name)
-        if !associations_loaded.include?(file_name)
-          associations_loaded << file_name
-          reload_associations ? silence_warnings { load("#{file_name}.rb") } : require(file_name)
-        end
-      end
-
-      # Resets the list of dependencies loaded (typically to be called by the end of a request), so when require_association is
-      # called for that dependency it'll be loaded anew.
-      def reset_associations_loaded
-        self.associations_loaded = []
-      end
-      
-      # Reload all the associations that have already been loaded once.
-      def reload_associations_loaded
-        associations_loaded.each do |file_name| 
-          begin
-            silence_warnings { load("#{file_name}.rb") }
-          rescue LoadError
-            # The association didn't reside in its own file, so we assume it was required by other means
-          end
-        end
-      end
-
       private
         # Raises an exception if an invalid option has been specified to prevent misspellings from slipping through 
         def validate_options(valid_option_keys, supplied_option_keys)
@@ -619,13 +573,7 @@ module ActiveRecord
         end
 
         def require_association_class(class_name)
-          return unless class_name
-          
-          begin
-            require_association(Inflector.underscore(class_name))
-          rescue LoadError
-            # Failed to load the associated class -- let's hope the developer is doing the requiring himself.
-          end
+          require_association(Inflector.underscore(class_name)) if class_name
         end
     end
   end

data/lib/active_record/associations/association_collection.rb

@@ -22,8 +22,8 @@ module ActiveRecord
         @collection.to_ary
       end
   
-      def respond_to?(symbol)
-        proxy_respond_to?(symbol) || [].respond_to?(symbol)
+      def respond_to?(symbol, include_priv = false)
+        proxy_respond_to?(symbol, include_priv) || [].respond_to?(symbol, include_priv)
       end
 
       def loaded?
@@ -100,13 +100,25 @@ module ActiveRecord
         def interpolate_sql(sql, record = nil)
           @owner.send(:interpolate_sql, sql, record)
         end
-      
+
+        def sanitize_sql(sql)
+          @association_class.send(:sanitize_sql, sql)
+        end
+
+        def extract_options_from_args!(args)
+          @owner.send(:extract_options_from_args!, args)
+        end
+
       private
         def load_collection
-          begin
-            @collection = find_all_records unless loaded?
-          rescue ActiveRecord::RecordNotFound
-            @collection = []
+          if loaded?
+            @collection
+          else
+            begin
+              @collection = find_all_records
+            rescue ActiveRecord::RecordNotFound
+              @collection = []
+            end
           end
         end
 
@@ -114,25 +126,10 @@ module ActiveRecord
           raise ActiveRecord::AssociationTypeMismatch, "#{@association_class} expected, got #{record.class}" unless record.is_a?(@association_class)
         end
 
-
-        def load_collection_to_array
-          return unless @collection_array.nil? 
-          begin
-            @collection_array = find_all_records
-          rescue ActiveRecord::StatementInvalid, ActiveRecord::RecordNotFound
-            @collection_array = []
-          end       
-        end
-        
-        def duplicated_records_array(records)
-          records = [records] unless records.is_a?(Array) || records.is_a?(ActiveRecord::Associations::AssociationCollection)
-          records.dup
-        end
-
         # Array#flatten has problems with rescursive arrays. Going one level deeper solves the majority of the problems.
         def flatten_deeper(array)
           array.collect { |element| element.respond_to?(:flatten) ? element.flatten : element }.flatten
         end
     end
   end
-end
+end