activerecord 1.12.2 → 1.13.0

data/CHANGELOG

@@ -1,3 +1,95 @@
+*1.13.0* (November 7th, 2005)
+
+* Fixed faulty regex in get_table_name method (SQLServerAdapter) #2639 [Ryan Tomayko]
+
+* Added :include as an option for association declarations [DHH]. Example:
+
+    has_many :posts, :include => [ :author, :comments ]
+
+* Rename Base.constrain to Base.with_scope so it doesn't conflict with existing concept of database constraints.  Make scoping more robust: uniform method => parameters, validated method names and supported finder parameters, raise exception on nested scopes.  [Jeremy Kemper]  Example:
+
+    Comment.with_scope(:find => { :conditions => 'active=true' }, :create => { :post_id => 5 }) do
+      # Find where name = ? and active=true
+      Comment.find :all, :conditions => ['name = ?', name]
+      # Create comment associated with :post_id
+      Comment.create :body => "Hello world"
+    end
+
+* Fixed that SQL Server should ignore :size declarations on anything but integer and string in the agnostic schema representation #2756 [Ryan Tomayko]
+
+* Added constrain scoping for creates using a hash of attributes bound to the :creation key [DHH]. Example:
+
+    Comment.constrain(:creation => { :post_id => 5 }) do
+      # Associated with :post_id
+      Comment.create :body => "Hello world"
+    end
+  
+  This is rarely used directly, but allows for find_or_create on associations. So you can do:
+  
+    # If the tag doesn't exist, a new one is created that's associated with the person
+    person.tags.find_or_create_by_name("Summer")
+
+* Added find_or_create_by_X as a second type of dynamic finder that'll create the record if it doesn't already exist [DHH]. Example:
+
+    # No 'Summer' tag exists
+    Tag.find_or_create_by_name("Summer") # equal to Tag.create(:name => "Summer")
+    
+    # Now the 'Summer' tag does exist
+    Tag.find_or_create_by_name("Summer") # equal to Tag.find_by_name("Summer")
+
+* Added extension capabilities to has_many and has_and_belongs_to_many proxies [DHH]. Example:
+
+    class Account < ActiveRecord::Base
+      has_many :people do
+        def find_or_create_by_name(name)
+          first_name, *last_name = name.split
+          last_name = last_name.join " "
+
+          find_or_create_by_first_name_and_last_name(first_name, last_name)
+        end
+      end
+    end
+
+    person = Account.find(:first).people.find_or_create_by_name("David Heinemeier Hansson")
+    person.first_name # => "David"
+    person.last_name  # => "Heinemeier Hansson"
+
+  Note that the anoymous module must be declared using brackets, not do/end (due to order of evaluation).
+
+* Omit internal dtproperties table from SQLServer table list.  #2729 [rtomayko@gmail.com]
+
+* Quote column names in generated SQL.  #2728 [rtomayko@gmail.com]
+
+* Correct the pure-Ruby MySQL 4.1.1 shim's version test.  #2718 [Jeremy Kemper]
+
+* Add Model.create! to match existing model.save! method.  When save! raises RecordInvalid, you can catch the exception, retrieve the invalid record (invalid_exception.record), and see its errors (invalid_exception.record.errors).  [Jeremy Kemper]
+
+* Correct fixture behavior when table name pluralization is off.  #2719 [Rick Bradley <rick@rickbradley.com>]
+
+* Changed :dbfile to :database for SQLite adapter for consistency (old key still works as an alias) #2644 [Dan Peterson]
+
+* Added migration support for Oracle #2647 [Michael Schoen]
+
+* Worked around that connection can't be reset if allow_concurrency is off.  #2648 [Michael Schoen <schoenm@earthlink.net>]
+
+* Fixed SQL Server adapter to pass even more tests and do even better #2634 [rtomayko@gmail.com]
+
+* Fixed SQL Server adapter so it honors options[:conditions] when applying :limits #1978 [Tom Ward]
+
+* Added migration support to SQL Server adapter (please someone do the same for Oracle and DB2) #2625 [Tom Ward]
+
+* Use AR::Base.silence rather than AR::Base.logger.silence in fixtures to preserve Log4r compatibility.  #2618 [dansketcher@gmail.com]
+
+* Constraints are cloned so they can't be inadvertently modified while they're
+in effect.  Added :readonly finder constraint.  Calling an association collection's class method (Part.foobar via item.parts.foobar) constrains :readonly => false since the collection's :joins constraint would otherwise force it to true.  [Jeremy Kemper <rails@bitsweat.net>]
+
+* Added :offset and :limit to the kinds of options that Base.constrain can use #2466 [duane.johnson@gmail.com]
+
+* Fixed handling of nil number columns on Oracle and cleaned up tests for Oracle in general #2555 [schoenm@earthlink.net]
+
+* Added quoted_true and quoted_false methods and tables to db2_adapter and cleaned up tests for DB2 #2493, #2624 [maik schmidt]
+
+
 *1.12.2* (October 26th, 2005)
 
 * Allow symbols to rename columns when using SQLite adapter. #2531 [kevin.clark@gmail.com]

data/README

@@ -1,14 +1,14 @@
 = Active Record -- Object-relation mapping put on rails
 
 Active Record connects business objects and database tables to create a persistable
-domain model where logic and data is presented in one wrapping. It's an implementation 
+domain model where logic and data are presented in one wrapping. It's an implementation 
 of the object-relational mapping (ORM) pattern[http://www.martinfowler.com/eaaCatalog/activeRecord.html] 
 by the same name as described by Martin Fowler:
 
   "An object that wraps a row in a database table or view, encapsulates 
        the database access, and adds domain logic on that data."
 
-Active Records main contribution to the pattern is to relieve the original of two stunting problems:
+Active Record's main contribution to the pattern is to relieve the original of two stunting problems:
 lack of associations and inheritance. By adding a simple domain language-like set of macros to describe
 the former and integrating the Single Table Inheritance pattern for the latter, Active Record narrows the
 gap of functionality between the data mapper and active record approach.
@@ -157,7 +157,7 @@ A short rundown of the major features:
 
      pkId = 1234
      cat = Cat.find(pkId)
-     # something even more interesting involving a the same cat...
+     # something even more interesting involving the same cat...
      cat.save
 
   {Learn more}[link:classes/ActiveRecord/Base.html]
@@ -165,7 +165,7 @@ A short rundown of the major features:
 
 * Database abstraction through simple adapters (~100 lines) with a shared connector
 
-   ActiveRecord::Base.establish_connection(:adapter => "sqlite", :dbfile => "dbfile")
+   ActiveRecord::Base.establish_connection(:adapter => "sqlite", :database => "dbfile")
 
    ActiveRecord::Base.establish_connection(
      :adapter  => "mysql", 
@@ -189,7 +189,7 @@ A short rundown of the major features:
 
 Data definitions are specified only in the database. Active Record queries the database for 
 the column names (that then serves to determine which attributes are valid) on regular
-objects instantiation through the new constructor and relies on the column names in the rows
+object instantiation through the new constructor and relies on the column names in the rows
 with the finders.
  
    # CREATE TABLE companies (
@@ -235,7 +235,7 @@ Active Record will also automatically link the "Person" object to the "people" t
 
 == Simple example (2/2): Using the domain
 
-Picking a database connection for all the active records
+Picking a database connection for all the Active Records
 
    ActiveRecord::Base.establish_connection(
      :adapter  => "mysql", 
@@ -300,9 +300,9 @@ It's also highly recommended to have a look at the unit tests. Read more in link
 
 == Philosophy 
 
-Active Record attempts to provide a coherent wrapping for the inconvenience that is 
+Active Record attempts to provide a coherent wrapper as a solution for the inconvenience that is 
 object-relational mapping. The prime directive for this mapping has been to minimize
-the amount of code needed to built a real-world domain model. This is made possible
+the amount of code needed to build a real-world domain model. This is made possible
 by relying on a number of conventions that make it easy for Active Record to infer
 complex relations and structures from a minimal amount of explicit direction.
 
@@ -357,4 +357,4 @@ RubyForge page at http://rubyforge.org/projects/activerecord. And as Jim from Ra
    new feature to be submitted in the form of new unit tests.
 
 For other information, feel free to ask on the ruby-talk mailing list
-(which is mirrored to comp.lang.ruby) or contact mailto:david@loudthinking.com.
+(which is mirrored to comp.lang.ruby) or contact mailto:david@loudthinking.com.

data/lib/active_record/acts/list.rb

@@ -6,7 +6,7 @@ module ActiveRecord
         base.extend(ClassMethods)
       end
       
-      # This act provides the capabilities for sorting and reordering a number of objects in list.
+      # This act provides the capabilities for sorting and reordering a number of objects in a list.
       # The class that has this specified needs to have a "position" column defined as an integer on
       # the mapped database table.
       #

data/lib/active_record/acts/nested_set.rb

@@ -7,17 +7,17 @@ module ActiveRecord
       end  
 
       # This acts provides Nested Set functionality.  Nested Set is similiar to Tree, but with
-      # the added feature that you can select the children and all of it's descendants with
+      # the added feature that you can select the children and all of their descendents with
       # a single query.  A good use case for this is a threaded post system, where you want
       # to display every reply to a comment without multiple selects.
       #
       # A google search for "Nested Set" should point you in the direction to explain the
-      # data base theory.  I figured a bunch of this from
+      # database theory.  I figured out a bunch of this from
       # http://threebit.net/tutorials/nestedset/tutorial1.html
       #
-      # Instead of picturing a leaf node structure with child pointing back to their parent,
+      # Instead of picturing a leaf node structure with children pointing back to their parent,
       # the best way to imagine how this works is to think of the parent entity surrounding all
-      # of it's children, and it's parent surrounding it, etc.  Assuming that they are lined up
+      # of its children, and its parent surrounding it, etc.  Assuming that they are lined up
       # horizontally, we store the left and right boundries in the database.
       #
       # Imagine:
@@ -42,7 +42,7 @@ module ActiveRecord
       #    |   |___________________________|   |___________________________|   |
       #    |___________________________________________________________________| 
       #
-      # The numbers represent the left and right boundries.  The table them might
+      # The numbers represent the left and right boundries.  The table then might
       # look like this:
       #    ID | PARENT | LEFT | RIGHT | DATA
       #     1 |      0 |    1 |    14 | root
@@ -63,10 +63,10 @@ module ActiveRecord
       # There are instance methods for all of these.
       #
       # The structure is good if you need to group things together; the downside is that
-      # keeping data integrity is a pain, and both adding and removing and entry
+      # keeping data integrity is a pain, and both adding and removing an entry
       # require a full table write.        
       #
-      # This sets up a before_destroy trigger to prune the tree correctly if one of it's
+      # This sets up a before_destroy trigger to prune the tree correctly if one of its
       # elements gets deleted.
       #
       module ClassMethods                      
@@ -134,10 +134,10 @@ module ActiveRecord
         end
 
                      
-        # Added a child to this object in the tree.  If this object hasn't been initialized,
+        # Adds a child to this object in the tree.  If this object hasn't been initialized,
         # it gets set up as a root node.  Otherwise, this method will update all of the
-        # other elements in the tree and shift them to the right. Keeping everything
-        # balanaced. 
+        # other elements in the tree and shift them to the right, keeping everything
+        # balanced. 
         def add_child( child )     
           self.reload
           child.reload
@@ -179,17 +179,17 @@ module ActiveRecord
           return (self[right_col_name] - self[left_col_name] - 1)/2
         end
                                                                
-        # Returns a set of itself and all of it's nested children
+        # Returns a set of itself and all of its nested children
         def full_set
           self.class.find(:all, :conditions => "#{scope_condition} AND (#{left_col_name} BETWEEN #{self[left_col_name]} and #{self[right_col_name]})" )
         end
                   
-        # Returns a set of all of it's children and nested children
+        # Returns a set of all of its children and nested children
         def all_children
           self.class.find(:all, :conditions => "#{scope_condition} AND (#{left_col_name} > #{self[left_col_name]}) and (#{right_col_name} < #{self[right_col_name]})" )
         end
                                   
-        # Returns a set of only this entries immediate children
+        # Returns a set of only this entry's immediate children
         def direct_children
           self.class.find(:all, :conditions => "#{scope_condition} and #{parent_column} = #{self.id}")
         end

data/lib/active_record/acts/tree.rb

@@ -6,8 +6,8 @@ module ActiveRecord
         base.extend(ClassMethods)              
       end  
 
-      # Specify this act if you want to model a tree structure by providing a parent association and an children 
-      # association. This act assumes that requires that you have a foreign key column, which by default is called parent_id.
+      # Specify this act if you want to model a tree structure by providing a parent association and a children 
+      # association. This act requires that you have a foreign key column, which by default is called parent_id.
       # 
       #   class Category < ActiveRecord::Base
       #     acts_as_tree :order => "name"
@@ -30,13 +30,14 @@ module ActiveRecord
       #
       # 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)
+      # * siblings          : Returns all the children of the parent, excluding the current node ([ subchild2 ] when called from subchild1)
+      # * self_and_siblings : Returns all the children of the parent, including the current node ([ subchild1, 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:
         #
-        # * <tt>foreign_key</tt> - specifies the column name to use for track of the tree (default: parent_id)
+        # * <tt>foreign_key</tt> - specifies the column name to use for tracking 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 = {})

data/lib/active_record/aggregations.rb

@@ -7,8 +7,8 @@ module ActiveRecord
 
     # Active Record implements aggregation through a macro-like class method called +composed_of+ for representing attributes 
     # as value objects. It expresses relationships like "Account [is] composed of Money [among other things]" or "Person [is]
-    # composed of [an] address". Each call to the macro adds a description on how the value objects are created from the 
-    # attributes of the entity object (when the entity is initialized either as a new object or from finding an existing) 
+    # composed of [an] address". Each call to the macro adds a description of how the value objects are created from the 
+    # attributes of the entity object (when the entity is initialized either as a new object or from finding an existing object) 
     # and how it can be turned back into attributes (when the entity is saved to the database). Example:
     #
     #   class Customer < ActiveRecord::Base
@@ -88,8 +88,8 @@ module ActiveRecord
     # == Writing value objects
     #
     # Value objects are immutable and interchangeable objects that represent a given value, such as a Money object representing
-    # $5. Two Money objects both representing $5 should be equal (through methods such == and <=> from Comparable if ranking makes
-    # sense). This is unlike a entity objects where equality is determined by identity. An entity class such as Customer can
+    # $5. Two Money objects both representing $5 should be equal (through methods such as == and <=> from Comparable if ranking
+    # makes sense). This is unlike entity objects where equality is determined by identity. An entity class such as Customer can
     # easily have two different objects that both have an address on Hyancintvej. Entity identity is determined by object or
     # relational unique identifiers (such as primary keys). Normal ActiveRecord::Base classes are entity objects.
     #

data/lib/active_record/associations.rb

@@ -22,7 +22,7 @@ module ActiveRecord
     
     # Associations are a set of macro-like class methods for tying objects together through foreign keys. They express relationships like 
     # "Project has one Project Manager" or "Project belongs to a Portfolio". Each macro adds a number of methods to the class which are 
-    # specialized according to the collection or association symbol and the options hash. It works much the same was as Ruby's own attr* 
+    # specialized according to the collection or association symbol and the options hash. It works much the same way as Ruby's own attr* 
     # methods. Example:
     #
     #   class Project < ActiveRecord::Base
@@ -80,7 +80,7 @@ module ActiveRecord
     #
     # === One-to-one associations
     #
-    # * Assigning an object to a has_one association automatically saves that object, and the object being replaced (if there is one), in
+    # * Assigning an object to a has_one association automatically saves that object and the object being replaced (if there is one), in
     #   order to update their primary keys - except if the parent object is unsaved (new_record? == true).
     # * If either of these saves fail (due to one of the objects being invalid) the assignment statement returns false and the assignment
     #   is cancelled.
@@ -120,6 +120,46 @@ module ActiveRecord
     # Should any of the before_add callbacks throw an exception, the object does not get added to the collection. Same with
     # the before_remove callbacks, if an exception is thrown the object doesn't get removed.
     #
+    # === Association extensions
+    #
+    # The proxy objects that controls the access to associations can be extended through anonymous modules. This is especially
+    # beneficial for adding new finders, creators, and other factory-type methods that are only used as part of this associatio.
+    # Example:
+    #
+    #   class Account < ActiveRecord::Base
+    #     has_many :people do
+    #       def find_or_create_by_name(name)
+    #         first_name, *last_name = name.split
+    #         last_name = last_name.join " "
+    #   
+    #         find_or_create_by_first_name_and_last_name(first_name, last_name)
+    #       end
+    #     end
+    #   end
+    #
+    #   person = Account.find(:first).people.find_or_create_by_name("David Heinemeier Hansson")
+    #   person.first_name # => "David"
+    #   person.last_name  # => "Heinemeier Hansson"
+    #
+    # If you need to share the same extensions between many associations, you can use a named extension module. Example:
+    #
+    #   module FindOrCreateByNameExtension
+    #     def find_or_create_by_name(name)
+    #       first_name, *last_name = name.split
+    #       last_name = last_name.join " "
+    #     
+    #       find_or_create_by_first_name_and_last_name(first_name, last_name)
+    #     end
+    #   end
+    #
+    #   class Account < ActiveRecord::Base
+    #     has_many :people, :extend => FindOrCreateByNameExtension
+    #   end
+    #
+    #   class Company < ActiveRecord::Base
+    #     has_many :people, :extend => FindOrCreateByNameExtension
+    #   end
+    #
     # == Caching
     #
     # All of the methods are built on a simple caching principle that will keep the result of the last query around unless specifically
@@ -164,8 +204,8 @@ module ActiveRecord
     #
     # That'll add another join along the lines of: LEFT OUTER JOIN comments ON comments.post_id = posts.id. And we'll be down to 1 query.
     # But that shouldn't fool you to think that you can pull out huge amounts of data with no performance penalty just because you've reduced
-    # 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.
+    # the number of queries. The database still needs to send all the data to Active Record and it still needs to be processed. So it's no
+    # catch-all for performance problems, but it's a great way to cut down on the number of queries in a situation as the one described above.
     #
     # 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:
@@ -240,10 +280,10 @@ module ActiveRecord
       # * <tt>collection.find</tt> - finds an associated object according to the same rules as Base.find.
       # * <tt>collection.build(attributes = {})</tt> - returns a new object of the collection type that has been instantiated
       #   with +attributes+ and linked to this object through a foreign key but has not yet been saved. *Note:* This only works if an 
-      #   associated object already exists, not if its nil!
+      #   associated object already exists, not if it's nil!
       # * <tt>collection.create(attributes = {})</tt> - returns a new object of the collection type that has been instantiated
       #   with +attributes+ and linked to this object through a foreign key and that has already been saved (if it passed the validation).
-      #   *Note:* This only works if an associated object already exists, not if its nil!
+      #   *Note:* This only works if an associated object already exists, not if it's nil!
       #
       # Example: A Firm class declares <tt>has_many :clients</tt>, which will add:
       # * <tt>Firm#clients</tt> (similar to <tt>Clients.find :all, :conditions => "firm_id = #{id}"</tt>)
@@ -271,7 +311,7 @@ module ActiveRecord
       #   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 :destroy (or true) all the associated objects are destroyed
-      #   alongside this object. Also accepts :nullify which will set the associated objects foriegn key
+      #   alongside this object. Also accepts :nullify which will set the associated object's foreign 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
@@ -279,12 +319,15 @@ module ActiveRecord
       #   clean-up in before_destroy. The upside is that it's much faster, especially if there's a counter_cache involved.
       #   May not be set if :dependent is also set.
       # * <tt>:finder_sql</tt>  - specify a complete SQL statement to fetch the association. This is a good way to go for complex
-      #   associations that depends on multiple tables. Note: When this option is used, +find_in_collection+ is _not_ added.
+      #   associations that depend on multiple tables. Note: When this option is used, +find_in_collection+ is _not_ added.
       # * <tt>:counter_sql</tt>  - specify a complete SQL statement to fetch the size of the association. If +:finder_sql+ is
       #   specified but +:counter_sql+, +:counter_sql+ will be generated by replacing SELECT ... FROM with SELECT COUNT(*) FROM.
+      # * <tt>:extend</tt>  - specify a named module for extending the proxy, see "Association extensions".
+      # * <tt>:include</tt>  - specify second-order associations that should be eager loaded when the collection is loaded.
       #
       # Option examples:
       #   has_many :comments, :order => "posted_on"
+      #   has_many :comments, :include => :author
       #   has_many :people, :class_name => "Person", :conditions => "deleted = 0", :order => "name"
       #   has_many :tracks, :order => "position", :dependent => true
       #   has_many :subscribers, :class_name => "Person", :finder_sql =>
@@ -292,13 +335,15 @@ module ActiveRecord
       #       'FROM people p, post_subscriptions ps ' +
       #       'WHERE ps.post_id = #{id} AND ps.person_id = p.id ' +
       #       'ORDER BY p.first_name'
-      def has_many(association_id, options = {})
+      def has_many(association_id, options = {}, &extension)
         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 
+          :conditions, :order, :include, :finder_sql, :counter_sql, 
+          :before_add, :after_add, :before_remove, :after_remove, :extend
         )
 
+        options[:extend] = create_extension_module(association_id, extension) if block_given?
+
         association_name, association_class_name, association_class_primary_key_name =
               associate_identification(association_id, options[:class_name], options[:foreign_key])
  
@@ -369,18 +414,19 @@ 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 :destroy (or true) all the associated object is destroyed when this object is. Also
+      # * <tt>:dependent</tt>   - if set to :destroy (or true) all the associated objects are 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"
       #   as the default foreign_key.
+      # * <tt>:include</tt>  - specify second-order associations that should be eager loaded when this object is loaded.
       #
       # Option examples:
       #   has_one :credit_card, :dependent => true
       #   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 = {})
-        options.assert_valid_keys(:class_name, :foreign_key, :remote, :conditions, :order, :dependent, :counter_cache)
+        options.assert_valid_keys(:class_name, :foreign_key, :remote, :conditions, :order, :include, :dependent, :counter_cache, :extend)
 
         association_name, association_class_name, association_class_primary_key_name =
             associate_identification(association_id, options[:class_name], options[:foreign_key], false)
@@ -453,6 +499,7 @@ module ActiveRecord
       #   and decrement_counter. The counter cache is incremented when an object of this class is created and decremented when it's
       #   destroyed. This requires that a column named "#{table_name}_count" (such as comments_count for a belonging Comment class)
       #   is used on the associate class (such as a Post class).
+      # * <tt>:include</tt>  - specify second-order associations that should be eager loaded when this object is loaded.
       #
       # Option examples:
       #   belongs_to :firm, :foreign_key => "client_of"
@@ -460,7 +507,7 @@ module ActiveRecord
       #   belongs_to :valid_coupon, :class_name => "Coupon", :foreign_key => "coupon_id", 
       #              :conditions => 'discounts > #{payments_count}'
       def belongs_to(association_id, options = {})
-        options.assert_valid_keys(:class_name, :foreign_key, :remote, :conditions, :order, :dependent, :counter_cache)
+        options.assert_valid_keys(:class_name, :foreign_key, :remote, :conditions, :order, :include, :dependent, :counter_cache, :extend)
 
         association_name, association_class_name, class_primary_key_name =
             associate_identification(association_id, options[:class_name], options[:foreign_key], false)
@@ -558,8 +605,8 @@ module ActiveRecord
       #   of this class in lower-case and "_id" suffixed. So a +Person+ class that makes a has_and_belongs_to_many association
       #   will use "person_id" as the default foreign_key.
       # * <tt>:association_foreign_key</tt> - specify the association foreign key used for the association. By default this is
-      #   guessed to be the name of the associated class in lower-case and "_id" suffixed. So the associated class is +Project+
-      #   that makes a has_and_belongs_to_many association will use "project_id" as the default association foreign_key.
+      #   guessed to be the name of the associated class in lower-case and "_id" suffixed. So if the associated class is +Project+,
+      #   the has_and_belongs_to_many association will use "project_id" as the default association foreign_key.
       # * <tt>:conditions</tt>  - specify the conditions that the associated object must meet in order to be included as a "WHERE"
       #   sql fragment, such as "authorized = 1".
       # * <tt>:order</tt> - specify the order in which the associated objects are returned as a "ORDER BY" sql fragment, such as "last_name, first_name DESC"
@@ -569,20 +616,25 @@ module ActiveRecord
       #   classes with a manual one
       # * <tt>:insert_sql</tt> - overwrite the default generated SQL used to add links between the associated classes
       #   with a manual one
+      # * <tt>:extend</tt>  - anonymous module for extending the proxy, see "Association extensions".
+      # * <tt>:include</tt>  - specify second-order associations that should be eager loaded when the collection is loaded.
       #
       # Option examples:
       #   has_and_belongs_to_many :projects
+      #   has_and_belongs_to_many :projects, :include => [ :milestones, :manager ]
       #   has_and_belongs_to_many :nations, :class_name => "Country"
       #   has_and_belongs_to_many :categories, :join_table => "prods_cats"
       #   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 = {})
+      def has_and_belongs_to_many(association_id, options = {}, &extension)
         options.assert_valid_keys(
-          :class_name, :table_name, :foreign_key, :association_foreign_key, :conditions,
+          :class_name, :table_name, :foreign_key, :association_foreign_key, :conditions, :include,
           :join_table, :finder_sql, :delete_sql, :insert_sql, :order, :uniq, :before_add, :after_add, 
-          :before_remove, :after_remove
+          :before_remove, :after_remove, :extend
         )
 
+        options[:extend] = create_extension_module(association_id, extension) if block_given?
+
         association_name, association_class_name, association_class_primary_key_name =
               associate_identification(association_id, options[:class_name], options[:foreign_key])
 
@@ -893,7 +945,7 @@ module ActiveRecord
           connection.select_values(
             construct_finder_sql_for_association_limiting(options),
             "#{name} Load IDs For Limited Eager Loading"
-          ).collect { |id| "'#{id}'" }.join(", ")
+          ).collect { |id| connection.quote(id) }.join(", ")
         end
 
         def construct_finder_sql_for_association_limiting(options)
@@ -978,7 +1030,16 @@ module ActiveRecord
         def condition_word(sql)
           sql =~ /where/i ? " AND " : "WHERE "
         end
-    end
 
+        def create_extension_module(association_id, extension)
+          extension_module_name = "#{self.to_s}#{association_id.to_s.camelize}AssociationExtension"
+
+          silence_warnings do
+            Object.const_set(extension_module_name, Module.new(&extension))
+          end
+          
+          extension_module_name.constantize
+        end
+    end
   end
 end