activerecord 1.11.1 → 1.12.1

data/CHANGELOG

@@ -1,3 +1,201 @@
+*1.12.1* (October 19th, 2005)
+
+* Always parenthesize :conditions options so they may be safely combined with STI and constraints.
+
+* Correct PostgreSQL primary key sequence detection.  #2507 [tmornini@infomania.com]
+
+* Added support for using limits in eager loads that involve has_many and has_and_belongs_to_many associations
+
+
+*1.12.0* (October 16th, 2005)
+
+* Update/clean up documentation (rdoc)
+
+* PostgreSQL sequence support.  Use set_sequence_name in your model class to specify its primary key sequence.  #2292 [Rick Olson <technoweenie@gmail.com>, Robby Russell <robby@planetargon.com>]
+
+* Change default logging colors to work on both white and black backgrounds. [Sam Stephenson]
+
+* YAML fixtures support ordered hashes for fixtures with foreign key dependencies in the same table.  #1896 [purestorm@ggnore.net]
+
+* :dependent now accepts :nullify option. Sets the foreign key of the related objects to NULL instead of deleting them. #2015 [Robby Russell <robby@planetargon.com>] 
+
+* Introduce read-only records.  If you call object.readonly! then it will mark the object as read-only and raise ReadOnlyRecord if you call object.save.  object.readonly? reports whether the object is read-only.  Passing :readonly => true to any finder method will mark returned records as read-only.  The :joins option now implies :readonly, so if you use this option, saving the same record will now fail.  Use find_by_sql to work around.
+
+* Avoid memleak in dev mode when using fcgi
+
+* Simplified .clear on active record associations by using the existing delete_records method. #1906 [Caleb <me@cpb.ca>]
+
+* Delegate access to a customized primary key to the conventional id method. #2444. [Blair Zajac <blair@orcaware.com>]
+
+* Fix errors caused by assigning a has-one or belongs-to property to itself
+
+* Add ActiveRecord::Base.schema_format setting which specifies how databases should be dumped [Sam Stephenson]
+
+* Update DB2 adapter. #2206. [contact@maik-schmidt.de]
+
+* Corrections to SQLServer native data types. #2267.  [rails.20.clarry@spamgourmet.com]
+
+* Deprecated ActiveRecord::Base.threaded_connection in favor of ActiveRecord::Base.allow_concurrency.
+
+* Protect id attribute from mass assigment even when the primary key is set to something else. #2438. [Blair Zajac <blair@orcaware.com>]
+
+* Misc doc fixes (typos/grammar/etc.). #2430. [coffee2code]
+
+* Add test coverage for content_columns. #2432. [coffee2code]
+
+* Speed up for unthreaded environments. #2431. [skaes@web.de]
+
+* Optimization for Mysql selects using mysql-ruby extension greater than 2.6.3.  #2426. [skaes@web.de]
+
+* Speed up the setting of table_name. #2428. [skaes@web.de]
+
+* Optimize instantiation of STI subclass records. In partial fullfilment of #1236. [skaes@web.de]
+
+* Fix typo of 'constrains' to 'contraints'. #2069. [Michael Schuerig <michael@schuerig.de>]
+
+* Optimization refactoring for add_limit_offset!. In partial fullfilment of #1236. [skaes@web.de]
+
+* Add ability to get all siblings, including the current child, with acts_as_tree. Recloses #2140. [Michael Schuerig <michael@schuerig.de>]
+
+* Add geometric type for postgresql adapter. #2233 [akaspick@gmail.com]
+
+* Add option (true by default) to generate reader methods for each attribute of a record to avoid the overhead of calling method missing. In partial fullfilment of #1236. [skaes@web.de]
+
+* Add convenience predicate methods on Column class. In partial fullfilment of #1236. [skaes@web.de]
+
+* Raise errors when invalid hash keys are passed to ActiveRecord::Base.find. #2363  [Chad Fowler <chad@chadfowler.com>, Nicholas Seckar]
+
+* Added :force option to create_table that'll try to drop the table if it already exists before creating
+
+* Fix transactions so that calling return while inside a transaction will not leave an open transaction on the connection. [Nicholas Seckar]
+
+* Use foreign_key inflection uniformly.  #2156 [Blair Zajac <blair@orcaware.com>]
+
+* model.association.clear should destroy associated objects if :dependent => true instead of nullifying their foreign keys.  #2221 [joergd@pobox.com, ObieFernandez <obiefernandez@gmail.com>]
+
+* Returning false from before_destroy should cancel the action.  #1829 [Jeremy Huffman]
+
+* Recognize PostgreSQL NOW() default as equivalent to CURRENT_TIMESTAMP or CURRENT_DATE, depending on the column's type.  #2256 [mat <mat@absolight.fr>]
+
+* Extensive documentation for the abstract database adapter.  #2250 [François Beausoleil <fbeausoleil@ftml.net>]
+
+* Clean up Fixtures.reset_sequences for PostgreSQL.  Handle tables with no rows and models with custom primary keys.  #2174, #2183 [jay@jay.fm, Blair Zajac <blair@orcaware.com>]
+
+* Improve error message when nil is assigned to an attr which validates_size_of within a range.  #2022 [Manuel Holtgrewe <purestorm@ggnore.net>]
+
+* Make update_attribute use the same writer method that update_attributes uses.
+ #2237 [trevor@protocool.com]
+
+* Make migrations honor table name prefixes and suffixes. #2298 [Jakob S, Marcel Molina]
+
+* Correct and optimize PostgreSQL bytea escaping.  #1745, #1837 [dave@cherryville.org, ken@miriamtech.com, bellis@deepthought.org]
+
+* Fixtures should only reset a PostgreSQL sequence if it corresponds to an integer primary key named id.  #1749 [chris@chrisbrinker.com]
+
+* Standardize the interpretation of boolean columns in the Mysql and Sqlite adapters. (Use MysqlAdapter.emulate_booleans = false to disable this behavior)
+
+* Added new symbol-driven approach to activating observers with Base#observers= [DHH]. Example:
+
+    ActiveRecord::Base.observers = :cacher, :garbage_collector
+
+* Added AbstractAdapter#select_value and AbstractAdapter#select_values as convenience methods for selecting single values, instead of hashes, of the first column in a SELECT #2283 [solo@gatelys.com]
+
+* Wrap :conditions in parentheses to prevent problems with OR's #1871 [Jamis Buck]
+
+* Allow the postgresql adapter to work with the SchemaDumper. [Jamis Buck]
+
+* Add ActiveRecord::SchemaDumper for dumping a DB schema to a pure-ruby file, making it easier to consolidate large migration lists and port database schemas between databases. [Jamis Buck]
+
+* Fixed migrations for Windows when using more than 10 [David Naseby]
+
+* Fixed that the create_x method from belongs_to wouldn't save the association properly #2042 [Florian Weber]
+
+* Fixed saving a record with two unsaved belongs_to associations pointing to the same object #2023 [Tobias Luetke]
+
+* Improved migrations' behavior when the schema_info table is empty. [Nicholas Seckar]
+
+* Fixed that Observers didn't observe sub-classes #627 [Florian Weber]
+
+* Fix eager loading error messages, allow :include to specify tables using strings or symbols. Closes #2222 [Marcel Molina]
+
+* Added check for RAILS_CONNECTION_ADAPTERS on startup and only load the connection adapters specified within if its present (available in Rails through config.connection_adapters using the new config) #1958 [skae]
+
+* Fixed various problems with has_and_belongs_to_many when using customer finder_sql #2094 [Florian Weber]
+
+* Added better exception error when unknown column types are used with migrations #1814 [fbeausoleil@ftml.net]
+
+* Fixed "connection lost" issue with the bundled Ruby/MySQL driver (would kill the app after 8 hours of inactivity) #2163, #428 [kajism@yahoo.com]
+
+* Fixed comparison of Active Record objects so two new objects are not equal #2099 [deberg]
+
+* Fixed that the SQL Server adapter would sometimes return DBI::Timestamp objects instead of Time #2127 [Tom Ward]
+
+* Added the instance methods #root and #ancestors on acts_as_tree and fixed siblings to not include the current node #2142, #2140 [coffee2code]
+
+* Fixed that Active Record would call SHOW FIELDS twice (or more) for the same model when the cached results were available #1947 [sd@notso.net]
+
+* Added log_level and use_silence parameter to ActiveRecord::Base.benchmark. The first controls at what level the benchmark statement will be logged (now as debug, instead of info) and the second that can be passed false to include all logging statements during the benchmark block/
+
+* Make sure the schema_info table is created before querying the current version #1903
+
+* Fixtures ignore table name prefix and suffix #1987 [Jakob S]
+
+* Add documentation for index_type argument to add_index method for migrations #2005 [blaine@odeo.com]
+
+* Modify read_attribute to allow a symbol argument #2024 [Ken Kunz]
+
+* Make destroy return self #1913 [sebastian.kanthak@muehlheim.de]
+
+* Fix typo in validations documentation #1938 [court3nay]
+
+* Make acts_as_list work for insert_at(1) #1966 [hensleyl@papermountain.org]
+
+* Fix typo in count_by_sql documentation #1969 [Alexey Verkhovsky]
+
+* Allow add_column and create_table to specify NOT NULL #1712 [emptysands@gmail.com]
+
+* Fix create_table so that id column is implicitly added [Rick Olson]
+
+* Default sequence names for Oracle changed to #{table_name}_seq, which is the most commonly used standard. In addition, a new method ActiveRecord::Base#set_sequence_name allows the developer to set the sequence name per model. This is a non-backwards-compatible change -- anyone using the old-style "rails_sequence" will need to either create new sequences, or set: ActiveRecord::Base.set_sequence_name = "rails_sequence" #1798
+
+* OCIAdapter now properly handles synonyms, which are commonly used to separate out the schema owner from the application user #1798
+
+* Fixed the handling of camelCase columns names in Oracle #1798
+
+* Implemented for OCI the Rakefile tasks of :clone_structure_to_test, :db_structure_dump, and :purge_test_database, which enable Oracle folks to enjoy all the agile goodness of Rails for testing. Note that the current implementation is fairly limited -- only tables and sequences are cloned, not constraints or indexes. A full clone in Oracle generally requires some manual effort, and is version-specific. Post 9i, Oracle recommends the use of the DBMS_METADATA package, though that approach requires editing of the physical characteristics generated #1798
+
+* Fixed the handling of multiple blob columns in Oracle if one or more of them are null #1798
+
+* Added support for calling constrained class methods on has_many and has_and_belongs_to_many collections #1764 [Tobias Luetke]
+
+    class Comment < AR:B
+      def self.search(q)
+        find(:all, :conditions => ["body = ?", q])
+      end
+    end 
+
+    class Post < AR:B
+      has_many :comments
+    end
+
+    Post.find(1).comments.search('hi') # => SELECT * from comments WHERE post_id = 1 AND body = 'hi'
+  
+  NOTICE: This patch changes the underlying SQL generated by has_and_belongs_to_many queries. If your relying on that, such as
+  by explicitly referencing the old t and j aliases, you'll need to update your code. Of course, you _shouldn't_ be relying on
+  details like that no less than you should be diving in to touch private variables. But just in case you do, consider yourself
+  noticed :)
+
+* Added migration support for SQLite (using temporary tables to simulate ALTER TABLE) #1771 [Sam Stephenson]
+
+* Remove extra definition of supports_migrations? from abstract_adaptor.rb [Nicholas Seckar]
+
+* Fix acts_as_list so that moving next-to-last item to the bottom does not result in duplicate item positions
+
+* Fixed incompatibility in DB2 adapter with the new limit/offset approach #1718 [Maik Schmidt]
+
+* Added :select option to find which can specify a different value than the default *, like find(:all, :select => "first_name, last_name"), if you either only want to select part of the columns or exclude columns otherwise included from a join #1338 [Stefan Kaes]
+
+
 *1.11.1* (11 July, 2005)
 
 * Added support for limit and offset with eager loading of has_one and belongs_to associations. Using the options with has_many and has_and_belongs_to_many associations will now raise an ActiveRecord::ConfigurationError #1692 [Rick Olsen]

data/lib/active_record.rb

@@ -21,15 +21,17 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
 
-$:.unshift(File.dirname(__FILE__))
-$:.unshift(File.dirname(__FILE__) + "/../../activesupport/lib")
-
-begin
-  require 'active_support'  
-rescue LoadError
-  require 'rubygems'
-  require_gem 'activesupport'
+unless defined?(ActiveSupport)
+  begin
+    $:.unshift(File.dirname(__FILE__) + "/../../activesupport/lib")  
+    require 'active_support'  
+  rescue LoadError
+    require 'rubygems'
+    require_gem 'activesupport'
+  end
 end
 
 require 'active_record/base'
@@ -46,11 +48,13 @@ require 'active_record/acts/tree'
 require 'active_record/acts/nested_set'
 require 'active_record/locking'
 require 'active_record/migration'
+require 'active_record/schema'
 
 ActiveRecord::Base.class_eval do
   include ActiveRecord::Validations
   include ActiveRecord::Locking
   include ActiveRecord::Callbacks
+  include ActiveRecord::Observing
   include ActiveRecord::Timestamp
   include ActiveRecord::Associations
   include ActiveRecord::Aggregations
@@ -61,11 +65,12 @@ ActiveRecord::Base.class_eval do
   include ActiveRecord::Acts::NestedSet
 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/db2_adapter'
-require 'active_record/connection_adapters/oci_adapter'
+unless defined?(RAILS_CONNECTION_ADAPTERS)
+  RAILS_CONNECTION_ADAPTERS = %w(mysql postgresql sqlite sqlserver db2 oci)
+end
+
+RAILS_CONNECTION_ADAPTERS.each do |adapter|
+  require "active_record/connection_adapters/#{adapter}_adapter"
+end
 
 require 'active_record/query_cache'

data/lib/active_record/acts/list.rb

@@ -72,7 +72,7 @@ module ActiveRecord
       # the first in the list of all chapters.
       module InstanceMethods
         def insert_at(position = 1)
-          position == 1 ? add_to_list_top : insert_at_position(position)
+          insert_at_position(position)
         end
 
         def move_lower
@@ -163,17 +163,19 @@ module ActiveRecord
           # Overwrite this method to define the scope of the list changes
           def scope_condition() "1" end
 
-          def bottom_position_in_list
-            item = bottom_item
+          def bottom_position_in_list(except = nil)
+            item = bottom_item(except)
             item ? item.send(position_column) : 0
           end
 
-          def bottom_item
-            self.class.find(:first, :conditions => scope_condition, :order => "#{position_column} DESC")
+          def bottom_item(except = nil)
+            conditions = scope_condition
+            conditions = "#{conditions} AND id != #{except.id}" if except
+            self.class.find(:first, :conditions => conditions, :order => "#{position_column} DESC")
           end
 
           def assume_bottom_position
-            update_attribute(position_column, bottom_position_in_list.to_i + 1) unless last?
+            update_attribute(position_column, bottom_position_in_list(self).to_i + 1)
           end
   
           def assume_top_position

data/lib/active_record/acts/tree.rb

@@ -16,16 +16,23 @@ module ActiveRecord
       #   Example : 
       #   root
       #    \_ child1 
-      #         \_ sub-child1
+      #         \_ subchild1
+      #         \_ subchild2
       #
       #   root      = Category.create("name" => "root")
-      #   child1      = root.children.create("name" => "child1")
-      #   subchild1   = child1.children.create("name" => "subchild1")
+      #   child1    = root.children.create("name" => "child1")
+      #   subchild1 = child1.children.create("name" => "subchild1")
       #
-      #   root.parent # => nil
+      #   root.parent   # => nil
       #   child1.parent # => root
       #   root.children # => [child1]
       #   root.children.first.children.first # => subchild1
+      #
+      # In addition to the parent and children associations, the following instance methods are added to the class 
+      # after specifying the act:
+      # * siblings: Return all the children of the parent excluding the current node ([ subchild2 ] when called from subchild1)
+      # * ancestors: Returns all the ancestors of the current node ([child1, root] when called from subchild2)
+      # * root: Returns the root of the current node (root when called from subchild2)
       module ClassMethods
         # Configuration options are:
         #
@@ -48,15 +55,31 @@ module ActiveRecord
             end
           END
 
+          # Returns list of ancestors, starting from parent until root.
+          #
+          #   subchild1.ancestors # => [child1, root]
+          define_method(:ancestors) do
+            node, nodes = self, []
+            nodes << node = node.parent until not node.has_parent?
+            nodes
+          end
+
+          define_method(:root) do
+            node = self
+            node = node.parent until not node.has_parent?
+            node
+          end
+
           define_method(:siblings) do
-            if parent
-              self.class.find(:all, :conditions => [ "#{configuration[:foreign_key]} = ?", parent.id ], :order => configuration[:order])
-            else
-              self.class.roots
-            end
+            self_and_siblings - [self]
+          end
+
+          define_method(:self_and_siblings) do
+            has_parent? ? parent.children : self.class.roots
           end
+
         end
       end
     end
   end
-end
+end

data/lib/active_record/aggregations.rb

@@ -120,7 +120,7 @@ module ActiveRecord
       #   composed_of :address, :mapping => [ %w(address_street street), %w(address_city city) ]
       #   composed_of :gps_location
       def composed_of(part_id, options = {})
-        validate_options([ :class_name, :mapping ], options.keys)
+        options.assert_valid_keys(:class_name, :mapping)
 
         name        = part_id.id2name
         class_name  = options[:class_name] || name_to_class_name(name)
@@ -131,12 +131,6 @@ module ActiveRecord
       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)
-          unknown_option_keys = supplied_option_keys - valid_option_keys
-          raise(ActiveRecordError, "Unknown options: #{unknown_option_keys}") unless unknown_option_keys.empty?
-        end
-
         def name_to_class_name(name)
           name.capitalize.gsub(/_(.)/) { |s| $1.capitalize }
         end

data/lib/active_record/associations.rb

@@ -167,9 +167,14 @@ module ActiveRecord
     # the number of queries. The database still needs to send all the data to Active Record and it still needs to be processed. So its no
     # catch-all for performance problems, but its a great way to cut down on the number of queries in a situation as the one described above.
     #
-    # Please note that because eager loading is fetching both models and associations in the same grab, it doesn't make sense to use the
-    # :limit and :offset options on has_many and has_and_belongs_to_many associations and an ConfigurationError exception will be raised 
-    # if attempted. It does, however, work just fine with has_one and belongs_to associations.
+    # Please note that limited eager loading with has_many and has_and_belongs_to_many associations is not compatible with describing conditions
+    # on these eager tables. This will work:
+    #
+    #   Post.find(:all, :include => :comments, :conditions => "posts.title = 'magic forest'", :limit => 2)
+    #
+    # ...but this will not (and an ArgumentError will be raised):
+    #
+    #   Post.find(:all, :include => :comments, :conditions => "comments.body like 'Normal%'", :limit => 2)
     #
     # Also have in mind that since the eager loading is pulling from multiple tables, you'll have to disambiguate any column references
     # in both conditions and orders. So :order => "posts.id DESC" will work while :order => "id DESC" will not. This may require that
@@ -227,7 +232,9 @@ module ActiveRecord
       #   This will also destroy the objects if they're declared as belongs_to and dependent on this model.
       # * <tt>collection=objects</tt> - replaces the collections content by deleting and adding objects as appropriate.
       # * <tt>collection_singular_ids=ids</tt> - replace the collection by the objects identified by the primary keys in +ids+
-      # * <tt>collection.clear</tt> - removes every object from the collection. This does not destroy the objects.
+      # * <tt>collection.clear</tt> - removes every object from the collection. This destroys the associated objects if they
+      #   are <tt>:dependent</tt>, deletes them directly from the database if they are <tt>:exclusively_dependent</tt>,
+      #   and sets their foreign keys to NULL otherwise.
       # * <tt>collection.empty?</tt> - returns true if there are no associated objects.
       # * <tt>collection.size</tt> - returns the number of associated objects.
       # * <tt>collection.find</tt> - finds an associated object according to the same rules as Base.find.
@@ -263,7 +270,9 @@ module ActiveRecord
       # * <tt>:foreign_key</tt> - specify the foreign key used for the association. By default this is guessed to be the name
       #   of this class in lower-case and "_id" suffixed. So a +Person+ class that makes a has_many association will use "person_id"
       #   as the default foreign_key.
-      # * <tt>:dependent</tt>   - if set to true all the associated object are destroyed alongside this object.
+      # * <tt>:dependent</tt>   - if set to :destroy (or true) all the associated objects are destroyed
+      #   alongside this object. Also accepts :nullify which will set the associated objects foriegn key
+      #   field to NULL.
       #   May not be set if :exclusively_dependent is also set.
       # * <tt>:exclusively_dependent</tt>   - if set to true all the associated object are deleted in one SQL statement without having their
       #   before_destroy callback run. This should only be used on associations that depend solely on this class and don't need to do any
@@ -284,26 +293,39 @@ module ActiveRecord
       #       'WHERE ps.post_id = #{id} AND ps.person_id = p.id ' +
       #       'ORDER BY p.first_name'
       def has_many(association_id, options = {})
-        validate_options([ :foreign_key, :class_name, :exclusively_dependent, :dependent, :conditions, :order, :finder_sql, :counter_sql, 
-													 :before_add, :after_add, :before_remove, :after_remove ], options.keys)
+        options.assert_valid_keys(
+          :foreign_key, :class_name, :exclusively_dependent, :dependent, 
+          :conditions, :order, :finder_sql, :counter_sql, 
+          :before_add, :after_add, :before_remove, :after_remove 
+        )
+
         association_name, association_class_name, association_class_primary_key_name =
               associate_identification(association_id, options[:class_name], options[:foreign_key])
  
         require_association_class(association_class_name)
 
-        if options[:dependent] and options[:exclusively_dependent]
-          raise ArgumentError, ':dependent and :exclusively_dependent are mutually exclusive options.  You may specify one or the other.' # ' ruby-mode
+        raise ArgumentError, ':dependent and :exclusively_dependent are mutually exclusive options.  You may specify one or the other.' if options[:dependent] and options[:exclusively_dependent]
+          
         # See HasManyAssociation#delete_records.  Dependent associations
         # delete children, otherwise foreign key is set to NULL.
-        elsif options[:dependent]
-          module_eval "before_destroy '#{association_name}.each { |o| o.destroy }'"
-        elsif options[:exclusively_dependent]
+        case options[:dependent]
+          when :destroy, true  
+            module_eval "before_destroy '#{association_name}.each { |o| o.destroy }'"
+          when :nullify
+            module_eval "before_destroy { |record| #{association_class_name}.update_all(%(#{association_class_primary_key_name} = NULL),  %(#{association_class_primary_key_name} = \#{record.quoted_id})) }"
+          when nil, false
+            # pass
+          else
+            raise ArgumentError, 'The :dependent option expects either true, :destroy or :nullify' 
+        end   
+        
+        if options[:exclusively_dependent]
           module_eval "before_destroy { |record| #{association_class_name}.delete_all(%(#{association_class_primary_key_name} = \#{record.quoted_id})) }"
         end
 
         add_multiple_associated_save_callbacks(association_name)
-				add_association_callbacks(association_name, options)
-				
+        add_association_callbacks(association_name, options)
+
         collection_accessor_methods(association_name, association_class_name, association_class_primary_key_name, options, HasManyAssociation)
         
         # deprecated api
@@ -347,7 +369,7 @@ module ActiveRecord
       #   sql fragment, such as "rank = 5".
       # * <tt>:order</tt>       - specify the order from which the associated object will be picked at the top. Specified as
       #    an "ORDER BY" sql fragment, such as "last_name, first_name DESC"
-      # * <tt>:dependent</tt>   - if set to true, the associated object is destroyed when this object is. It's also destroyed if another
+      # * <tt>:dependent</tt>   - if set to :destroy (or true) all the associated object is destroyed when this object is. Also
       #   association is assigned.
       # * <tt>:foreign_key</tt> - specify the foreign key used for the association. By default this is guessed to be the name
       #   of this class in lower-case and "_id" suffixed. So a +Person+ class that makes a has_one association will use "person_id"
@@ -358,7 +380,7 @@ module ActiveRecord
       #   has_one :last_comment, :class_name => "Comment", :order => "posted_on"
       #   has_one :project_manager, :class_name => "Person", :conditions => "role = 'project_manager'"
       def has_one(association_id, options = {})
-        validate_options([ :class_name, :foreign_key, :remote, :conditions, :order, :dependent, :counter_cache ], options.keys)
+        options.assert_valid_keys(:class_name, :foreign_key, :remote, :conditions, :order, :dependent, :counter_cache)
 
         association_name, association_class_name, association_class_primary_key_name =
             associate_identification(association_id, options[:class_name], options[:foreign_key], false)
@@ -380,7 +402,16 @@ module ActiveRecord
         association_constructor_method(:build, association_name, association_class_name, association_class_primary_key_name, options, HasOneAssociation)
         association_constructor_method(:create, association_name, association_class_name, association_class_primary_key_name, options, HasOneAssociation)
         
-        module_eval "before_destroy '#{association_name}.destroy unless #{association_name}.nil?'" if options[:dependent]
+        case options[:dependent]
+          when :destroy, true
+            module_eval "before_destroy '#{association_name}.destroy unless #{association_name}.nil?'"
+          when :nullify
+            module_eval "before_destroy '#{association_name}.update_attribute(\"#{association_class_primary_key_name}\", nil)'"
+          when nil, false
+            # pass
+          else
+            raise ArgumentError, "The :dependent option expects either :destroy or :nullify."
+        end
 
         # deprecated api
         deprecated_has_association_method(association_name)
@@ -429,14 +460,14 @@ module ActiveRecord
       #   belongs_to :valid_coupon, :class_name => "Coupon", :foreign_key => "coupon_id", 
       #              :conditions => 'discounts > #{payments_count}'
       def belongs_to(association_id, options = {})
-        validate_options([ :class_name, :foreign_key, :remote, :conditions, :order, :dependent, :counter_cache ], options.keys)
+        options.assert_valid_keys(:class_name, :foreign_key, :remote, :conditions, :order, :dependent, :counter_cache)
 
         association_name, association_class_name, class_primary_key_name =
             associate_identification(association_id, options[:class_name], options[:foreign_key], false)
 
         require_association_class(association_class_name)
 
-        association_class_primary_key_name = options[:foreign_key] || Inflector.underscore(Inflector.demodulize(association_class_name)) + "_id"
+        association_class_primary_key_name = options[:foreign_key] || association_class_name.foreign_key
 
         association_accessor_methods(association_name, association_class_name, association_class_primary_key_name, options, BelongsToAssociation)
         association_constructor_method(:build, association_name, association_class_name, association_class_primary_key_name, options, BelongsToAssociation)
@@ -445,11 +476,13 @@ module ActiveRecord
         module_eval do
           before_save <<-EOF
             association = instance_variable_get("@#{association_name}")
-            if not association.nil? and association.new_record?
-              association.save(true)
-              self["#{association_class_primary_key_name}"] = association.id
-              association.send(:construct_sql)
-            end
+            if not association.nil? 
+              if association.new_record?
+                association.save(true)
+                association.send(:construct_sql)
+              end
+              self["#{association_class_primary_key_name}"] = association.id if association.updated?
+            end            
           EOF
         end
       
@@ -544,9 +577,12 @@ module ActiveRecord
       #   has_and_belongs_to_many :active_projects, :join_table => 'developers_projects', :delete_sql => 
       #   'DELETE FROM developers_projects WHERE active=1 AND developer_id = #{id} AND project_id = #{record.id}'
       def has_and_belongs_to_many(association_id, options = {})
-        validate_options([ :class_name, :table_name, :foreign_key, :association_foreign_key, :conditions,
-                           :join_table, :finder_sql, :delete_sql, :insert_sql, :order, :uniq, :before_add, :after_add, 
-                           :before_remove, :after_remove ], options.keys)
+        options.assert_valid_keys(
+          :class_name, :table_name, :foreign_key, :association_foreign_key, :conditions,
+          :join_table, :finder_sql, :delete_sql, :insert_sql, :order, :uniq, :before_add, :after_add, 
+          :before_remove, :after_remove
+        )
+
         association_name, association_class_name, association_class_primary_key_name =
               associate_identification(association_id, options[:class_name], options[:foreign_key])
 
@@ -570,12 +606,6 @@ module ActiveRecord
       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)
-          unknown_option_keys = supplied_option_keys - valid_option_keys
-          raise(ActiveRecord::ActiveRecordError, "Unknown options: #{unknown_option_keys}") unless unknown_option_keys.empty?
-        end
-        
         def join_table_name(first_table_name, second_table_name)
           if first_table_name < second_table_name
             join_table = "#{first_table_name}_#{second_table_name}"
@@ -594,7 +624,7 @@ module ActiveRecord
             )
           end
 
-          primary_key_name = foreign_key || Inflector.underscore(Inflector.demodulize(name)) + "_id"
+          primary_key_name = foreign_key || name.foreign_key
         
           return association_id.id2name, association_class_name, primary_key_name
         end
@@ -681,41 +711,39 @@ module ActiveRecord
         end
 
         def add_multiple_associated_save_callbacks(association_name)
-          module_eval do
-            before_save <<-end_eval
-              @new_record_before_save = new_record?
-              association = instance_variable_get("@#{association_name}")
-              if association.respond_to?(:loaded?)
-                if new_record?
-                  records_to_save = association
-                else
-                  records_to_save = association.select{ |record| record.new_record? }
-                end
-                records_to_save.inject(true) do |result,record|
-                  result &&= record.valid?
-                end
+          method_name = "validate_associated_records_for_#{association_name}".to_sym
+          define_method(method_name) do
+            @new_record_before_save = new_record?
+            association = instance_variable_get("@#{association_name}")
+            if association.respond_to?(:loaded?)
+              if new_record?
+                association
+              else
+                association.select { |record| record.new_record? }
+              end.each do |record|
+                errors.add "#{association_name}" unless record.valid?
               end
-            end_eval
+            end
           end
 
-          module_eval do
-            after_callback = <<-end_eval
-              association = instance_variable_get("@#{association_name}")
-              if association.respond_to?(:loaded?)
-                if @new_record_before_save
-                  records_to_save = association
-                else
-                  records_to_save = association.select{ |record| record.new_record? }
-                end
-                records_to_save.each{ |record| association.send(:insert_record, record) }
-                association.send(:construct_sql)   # reconstruct the SQL queries now that we know the owner's id
+          validate method_name
+
+          after_callback = <<-end_eval
+            association = instance_variable_get("@#{association_name}")
+            if association.respond_to?(:loaded?)
+              if @new_record_before_save
+                records_to_save = association
+              else
+                records_to_save = association.select { |record| record.new_record? }
               end
-            end_eval
+              records_to_save.each { |record| association.send(:insert_record, record) }
+              association.send(:construct_sql)   # reconstruct the SQL queries now that we know the owner's id
+            end
+          end_eval
 
-            # Doesn't use after_save as that would save associations added in after_create/after_update twice
-            after_create(after_callback)
-            after_update(after_callback)
-          end
+          # Doesn't use after_save as that would save associations added in after_create/after_update twice
+          after_create(after_callback)
+          after_update(after_callback)
         end
 
         def association_constructor_method(constructor, association_name, association_class_name, association_class_primary_key_name, options, association_proxy_class)
@@ -743,7 +771,6 @@ module ActiveRecord
           reflections  = reflect_on_included_associations(options[:include])
 
           guard_against_missing_reflections(reflections, options)
-          guard_against_unlimitable_reflections(reflections, options)
           
           schema_abbreviations = generate_schema_abbreviations(reflections)
           primary_key_table    = generate_primary_key_table(reflections, schema_abbreviations)
@@ -783,14 +810,15 @@ module ActiveRecord
 
 
         def reflect_on_included_associations(associations)
-          [ associations ].flatten.collect { |association| reflect_on_association(association) }
+          [ associations ].flatten.collect { |association| reflect_on_association(association.to_s.intern) }
         end
 
         def guard_against_missing_reflections(reflections, options)
           reflections.each do |r| 
             raise(
               ConfigurationError, 
-              "Association was not found; perhaps you misspelled it?  You specified :include => :#{options[:include].join(', :')}"
+              "Association was not found; perhaps you misspelled it?  " +
+              "You specified :include => :#{[options[:include]].flatten.join(', :')}"
             ) if r.nil? 
           end
         end
@@ -843,24 +871,61 @@ module ActiveRecord
           sql = "SELECT #{column_aliases(schema_abbreviations)} FROM #{table_name} "
           sql << reflections.collect { |reflection| association_join(reflection) }.to_s
           sql << "#{options[:joins]} " if options[:joins]
+
           add_conditions!(sql, options[:conditions])
           add_sti_conditions!(sql, reflections)
+          add_limited_ids_condition!(sql, options) if !using_limitable_reflections?(reflections) && options[:limit]
+
           sql << "ORDER BY #{options[:order]} " if options[:order]
+
           add_limit!(sql, options) if using_limitable_reflections?(reflections)
+
+          return sanitize_sql(sql)
+        end
+
+        def add_limited_ids_condition!(sql, options)
+          unless (id_list = select_limited_ids_list(options)).empty?
+            sql << "#{condition_word(sql)} #{table_name}.#{primary_key} IN (#{id_list}) "
+          end
+        end
+
+        def select_limited_ids_list(options)
+          connection.select_values(
+            construct_finder_sql_for_association_limiting(options),
+            "#{name} Load IDs For Limited Eager Loading"
+          ).collect { |id| "'#{id}'" }.join(", ")
+        end
+
+        def construct_finder_sql_for_association_limiting(options)
+          raise(ArgumentError, "Limited eager loads and conditions on the eager tables is incompatible") if include_eager_conditions?(options)
+          
+          sql = "SELECT #{primary_key} FROM #{table_name} "
+          add_conditions!(sql, options[:conditions])
+          sql << "ORDER BY #{options[:order]} " if options[:order]
+          add_limit!(sql, options)
           return sanitize_sql(sql)
         end
 
+        def include_eager_conditions?(options)
+          return false unless options[:conditions]
+          
+          options[:conditions].scan(/ ([^.]+)\.[^.]+ /).flatten.any? do |condition_table_name| 
+            condition_table_name != table_name
+          end
+        end
+
         def using_limitable_reflections?(reflections)
           reflections.reject { |r| [ :belongs_to, :has_one ].include?(r.macro) }.length.zero?
         end
 
         def add_sti_conditions!(sql, reflections)
-          sti_sql = ""
-          reflections.each do |reflection|
-            sti_sql << " AND #{reflection.klass.send(:type_condition)}" unless reflection.klass.descends_from_active_record?
+          sti_conditions = reflections.collect do |reflection|
+            reflection.klass.send(:type_condition) unless reflection.klass.descends_from_active_record?
+          end.compact
+          
+          unless sti_conditions.empty?
+            sql << condition_word(sql) + sti_conditions.join(" AND ")
           end
-          sti_sql.sub!(/AND/, "WHERE") unless sql =~ /where/i
-          sql << sti_sql
         end
 
         def column_aliases(schema_abbreviations)
@@ -890,16 +955,15 @@ module ActiveRecord
         end
 
         def add_association_callbacks(association_name, options)
-        	callbacks = %w(before_add after_add before_remove after_remove)
-        	callbacks.each do |callback_name|
-        	  full_callback_name = "#{callback_name.to_s}_for_#{association_name.to_s}"
-        	  defined_callbacks = options[callback_name.to_sym]
-        	  if options.has_key?(callback_name.to_sym)
-        	    callback_array = defined_callbacks.kind_of?(Array) ? defined_callbacks : [defined_callbacks]
-        	    class_inheritable_reader full_callback_name.to_sym
-              write_inheritable_array(full_callback_name.to_sym, callback_array)
-        	  end
-        	end
+          callbacks = %w(before_add after_add before_remove after_remove)
+          callbacks.each do |callback_name|
+            full_callback_name = "#{callback_name.to_s}_for_#{association_name.to_s}"
+            defined_callbacks = options[callback_name.to_sym]
+            if options.has_key?(callback_name.to_sym)
+              class_inheritable_reader full_callback_name.to_sym
+              write_inheritable_array(full_callback_name.to_sym, [defined_callbacks].flatten)
+            end
+          end
         end
 
         def extract_record(schema_abbreviations, table_name, row)
@@ -910,6 +974,11 @@ module ActiveRecord
           end
           return record
         end        
+
+        def condition_word(sql)
+          sql =~ /where/i ? " AND " : "WHERE "
+        end
     end
+
   end
 end