From 18a3333a30b406633e2bb6fa5b87ada25ce7571d Mon Sep 17 00:00:00 2001 From: Michael Koziarski Date: Tue, 28 Aug 2007 23:18:57 +0000 Subject: Formatting, grammar and spelling fixes for the associations documentation. [seanhussey] Closes #8899 git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@7368 5ecf4fe2-1ee6-0310-87b1-e25e094e27de --- activerecord/lib/active_record/aggregations.rb | 22 +- activerecord/lib/active_record/associations.rb | 316 ++++++++++----------- .../associations/association_collection.rb | 2 +- .../associations/association_proxy.rb | 2 +- .../has_and_belongs_to_many_association.rb | 6 +- .../associations/has_many_through_association.rb | 2 +- .../associations/has_one_association.rb | 2 +- activerecord/lib/active_record/callbacks.rb | 100 +++---- 8 files changed, 226 insertions(+), 226 deletions(-) (limited to 'activerecord/lib') diff --git a/activerecord/lib/active_record/aggregations.rb b/activerecord/lib/active_record/aggregations.rb index a137a11cd4..5be629e3d5 100644 --- a/activerecord/lib/active_record/aggregations.rb +++ b/activerecord/lib/active_record/aggregations.rb @@ -70,7 +70,7 @@ module ActiveRecord # end # # Now it's possible to access attributes from the database through the value objects instead. If you choose to name the - # composition the same as the attributes name, it will be the only way to access that attribute. That's the case with our + # composition the same as the attribute's name, it will be the only way to access that attribute. That's the case with our # +balance+ attribute. You interact with the value objects just like you would any other attribute, though: # # customer.balance = Money.new(20) # sets the Money value object and the attribute @@ -92,19 +92,19 @@ 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 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 + # 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 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. + # relational unique identifiers (such as primary keys). Normal ActiveRecord::Base classes are entity objects. # - # It's also important to treat the value objects as immutable. Don't allow the Money object to have its amount changed after - # creation. Create a new money object with the new value instead. This is exemplified by the Money#exchanged_to method that + # It's also important to treat the value objects as immutable. Don't allow the +Money+ object to have its amount changed after + # creation. Create a new +Money+ object with the new value instead. This is exemplified by the Money#exchanged_to method that # returns a new value object instead of changing its own values. Active Record won't persist value objects that have been - # changed through other means than the writer method. + # changed through means other than the writer method. # # The immutable requirement is enforced by Active Record by freezing any object assigned as a value object. Attempting to - # change it afterwards will result in a TypeError. + # change it afterwards will result in a TypeError. # # Read more about value objects on http://c2.com/cgi/wiki?ValueObject and on the dangers of not keeping value objects # immutable on http://c2.com/cgi/wiki?ValueObjectsShouldBeImmutable @@ -119,8 +119,8 @@ module ActiveRecord # * :mapping - specifies a number of mapping arrays (attribute, parameter) that bind an attribute name # to a constructor parameter on the value class. # * :allow_nil - specifies that the aggregate object will not be instantiated when all mapped - # attributes are nil. Setting the aggregate class to nil has the effect of writing nil to all mapped attributes. - # This defaults to false. + # attributes are +nil+. Setting the aggregate class to +nil+ has the effect of writing +nil+ to all mapped attributes. + # This defaults to +false+. # # Option examples: # composed_of :temperature, :mapping => %w(reading celsius) diff --git a/activerecord/lib/active_record/associations.rb b/activerecord/lib/active_record/associations.rb index 438e96a8ce..5e30160445 100755 --- a/activerecord/lib/active_record/associations.rb +++ b/activerecord/lib/active_record/associations.rb @@ -76,7 +76,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 way 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 @@ -146,12 +146,12 @@ module ActiveRecord # # ActiveRecord associations can be used to describe relations with one-to-one, one-to-many # and many-to-many cardinality. Each model uses an association to describe its role in - # the relation. In each case, the belongs_to association is used in the model that has + # the relation. In each case, the +belongs_to+ association is used in the model that has # the foreign key. # # === One-to-one # - # Use has_one in the base, and belongs_to in the associated model. + # Use +has_one+ in the base, and +belongs_to+ in the associated model. # # class Employee < ActiveRecord::Base # has_one :office @@ -162,7 +162,7 @@ module ActiveRecord # # === One-to-many # - # Use has_many in the base, and belongs_to in the associated model. + # Use +has_many+ in the base, and +belongs_to+ in the associated model. # # class Manager < ActiveRecord::Base # has_many :employees @@ -175,7 +175,7 @@ module ActiveRecord # # There are two ways to build a many-to-many relationship. # - # The first way uses a has_many association with the :through option and a join model, so + # The first way uses a +has_many+ association with the :through option and a join model, so # there are two stages of associations. # # class Assignment < ActiveRecord::Base @@ -191,7 +191,7 @@ module ActiveRecord # has_many :programmers, :through => :assignments # end # - # For the second way, use has_and_belongs_to_many in both models. This requires a join table + # For the second way, use +has_and_belongs_to_many+ in both models. This requires a join table # that has no corresponding model or primary key. # # class Programmer < ActiveRecord::Base @@ -201,15 +201,15 @@ module ActiveRecord # has_and_belongs_to_many :programmers # foreign keys in the join table # end # - # It is not always a simple decision which way of building a many-to-many relationship is best. - # But if you need to work with the relationship model as its own entity, then you'll need to - # use has_many :through. Use has_and_belongs_to_many when working with legacy schemas or when + # Choosing which way to build a many-to-many relationship is not always simple. + # If you need to work with the relationship model as its own entity, + # use has_many :through. Use +has_and_belongs_to_many+ when working with legacy schemas or when # you never work directly with the relationship itself. # - # == Is it a belongs_to or has_one association? + # == Is it a +belongs_to+ or +has_one+ association? # - # Both express a 1-1 relationship, the difference is mostly where to place the foreign key, which goes on the table for the class - # saying belongs_to. Example: + # Both express a 1-1 relationship. The difference is mostly where to place the foreign key, which goes on the table for the class + # declaring the +belongs_to+ relationship. Example: # # class User < ActiveRecord::Base # # I reference an account. @@ -243,26 +243,26 @@ 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 - # 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 + # * 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. - # * If you wish to assign an object to a has_one association without saving it, use the #association.build method (documented below). - # * Assigning an object to a belongs_to association does not save the object, since the foreign key field belongs on the parent. It does - # not save the parent either. + # * If you wish to assign an object to a +has_one+ association without saving it, use the #association.build method (documented below). + # * Assigning an object to a +belongs_to+ association does not save the object, since the foreign key field belongs on the parent. It + # does not save the parent either. # # === Collections # - # * Adding an object to a collection (has_many or has_and_belongs_to_many) automatically saves that object, except if the parent object + # * Adding an object to a collection (+has_many+ or +has_and_belongs_to_many+) automatically saves that object, except if the parent object # (the owner of the collection) is not yet stored in the database. - # * If saving any of the objects being added to a collection (via #push or similar) fails, then #push returns false. - # * You can add an object to a collection without automatically saving it by using the #collection.build method (documented below). - # * All unsaved (new_record? == true) members of the collection are automatically saved when the parent is saved. + # * If saving any of the objects being added to a collection (via #push or similar) fails, then #push returns +false+. + # * You can add an object to a collection without automatically saving it by using the #collection.build method (documented below). + # * All unsaved (new_record? == true) members of the collection are automatically saved when the parent is saved. # # === Association callbacks # # Similiar to the normal callbacks that hook into the lifecycle of an Active Record object, you can also define callbacks that get - # trigged when you add an object to or removing an object from a association collection. Example: + # trigged when you add an object to or remove an object from an association collection. Example: # # class Project # has_and_belongs_to_many :developers, :after_add => :evaluate_velocity @@ -278,14 +278,14 @@ module ActiveRecord # has_and_belongs_to_many :developers, :after_add => [:evaluate_velocity, Proc.new { |p, d| p.shipping_date = Time.now}] # end # - # Possible callbacks are: before_add, after_add, before_remove and after_remove. + # Possible callbacks are: +before_add+, +after_add+, +before_remove+ and +after_remove+. # - # 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. + # 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 + # The proxy objects that control 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 association. # Example: # @@ -319,7 +319,7 @@ module ActiveRecord # has_many :people, :extend => FindOrCreateByNameExtension # end # - # If you need to use multiple named extension modules, you can specify an array of modules with the :extend option. + # If you need to use multiple named extension modules, you can specify an array of modules with the :extend option. # In the case of name conflicts between methods in the modules, methods in modules later in the array supercede # those earlier in the array. Example: # @@ -332,12 +332,12 @@ module ActiveRecord # # * +proxy_owner+ - Returns the object the association is part of. # * +proxy_reflection+ - Returns the reflection object that describes the association. - # * +proxy_target+ - Returns the associated object for belongs_to and has_one, or the collection of associated objects for has_many and has_and_belongs_to_many. + # * +proxy_target+ - Returns the associated object for +belongs_to+ and +has_one+, or the collection of associated objects for +has_many+ and +has_and_belongs_to_many+. # # === Association Join Models # - # Has Many associations can be configured with the :through option to use an explicit join model to retrieve the data. This - # operates similarly to a has_and_belongs_to_many association. The advantage is that you're able to add validations, + # Has Many associations can be configured with the :through option to use an explicit join model to retrieve the data. This + # operates similarly to a +has_and_belongs_to_many+ association. The advantage is that you're able to add validations, # callbacks, and extra attributes on the join model. Consider the following schema: # # class Author < ActiveRecord::Base @@ -354,7 +354,7 @@ module ActiveRecord # @author.authorships.collect { |a| a.book } # selects all books that the author's authorships belong to. # @author.books # selects all books by using the Authorship join model # - # You can also go through a has_many association on the join model: + # You can also go through a +has_many+ association on the join model: # # class Firm < ActiveRecord::Base # has_many :clients @@ -377,25 +377,25 @@ module ActiveRecord # === Polymorphic Associations # # Polymorphic associations on models are not restricted on what types of models they can be associated with. Rather, they - # specify an interface that a has_many association must adhere to. + # specify an interface that a +has_many+ association must adhere to. # # class Asset < ActiveRecord::Base # belongs_to :attachable, :polymorphic => true # end # # class Post < ActiveRecord::Base - # has_many :assets, :as => :attachable # The :as option specifies the polymorphic interface to use. + # has_many :assets, :as => :attachable # The :as option specifies the polymorphic interface to use. # end # # @asset.attachable = @post # # This works by using a type column in addition to a foreign key to specify the associated record. In the Asset example, you'd need - # an attachable_id integer column and an attachable_type string column. + # an +attachable_id+ integer column and an +attachable_type+ string column. # # Using polymorphic associations in combination with single table inheritance (STI) is a little tricky. In order # for the associations to work as expected, ensure that you store the base model for the STI models in the # type column of the polymorphic association. To continue with the asset example above, suppose there are guest posts - # and member posts that use the posts table for STI. So there will be an additional 'type' column in the posts table. + # and member posts that use the posts table for STI. In this case, there must be a +type+ column in the posts table. # # class Asset < ActiveRecord::Base # belongs_to :attachable, :polymorphic => true @@ -431,7 +431,7 @@ module ActiveRecord # == Eager loading of associations # # Eager loading is a way to find objects of a certain class and a number of named associations along with it in a single SQL call. This is - # one of the easiest ways of to prevent the dreaded 1+N problem in which fetching 100 posts that each needs to display their author + # one of the easiest ways of to prevent the dreaded 1+N problem in which fetching 100 posts that each need to display their author # triggers 101 database queries. Through the use of eager loading, the 101 queries can be reduced to 1. Example: # # class Post < ActiveRecord::Base @@ -451,16 +451,16 @@ module ActiveRecord # # for post in Post.find(:all, :include => :author) # - # This references the name of the belongs_to association that also used the :author symbol, so the find will now weave in a join something - # like this: LEFT OUTER JOIN authors ON authors.id = posts.author_id. Doing so will cut down the number of queries from 201 to 101. + # This references the name of the +belongs_to+ association that also used the :author symbol, so the find will now weave in a join something + # like this: LEFT OUTER JOIN authors ON authors.id = posts.author_id. Doing so will cut down the number of queries from 201 to 101. # # We can improve upon the situation further by referencing both associations in the finder with: # # for post in Post.find(:all, :include => [ :author, :comments ]) # - # 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. + # 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. # - # To include a deep hierarchy of associations, using a hash: + # To include a deep hierarchy of associations, use a hash: # # for post in Post.find(:all, :include => [ :author, { :comments => { :author => :gravatar } } ]) # @@ -472,12 +472,12 @@ module ActiveRecord # 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. # # Since the eager loading pulls 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. Because eager loading generates the SELECT statement too, the - # :select option is ignored. + # :order => "posts.id DESC" will work while :order => "id DESC" will not. Because eager loading generates the +SELECT+ statement too, the + # :select option is ignored. # # You can use eager loading on multiple associations from the same table, but you cannot use those associations in orders and conditions # as there is currently not any way to disambiguate them. Eager loading will not pull additional attributes on join tables, so "rich - # associations" with has_and_belongs_to_many are not a good fit for eager loading. + # associations" with +has_and_belongs_to_many+ are not a good fit for eager loading. # # When eager loaded, conditions are interpolated in the context of the model class, not the model instance. Conditions are lazily interpolated # before the actual model exists. @@ -485,7 +485,7 @@ module ActiveRecord # == Table Aliasing # # ActiveRecord uses table aliasing in the case that a table is referenced multiple times in a join. If a table is referenced only once, - # the standard table name is used. The second time, the table is aliased as #{reflection_name}_#{parent_table_name}. Indexes are appended + # the standard table name is used. The second time, the table is aliased as #{reflection_name}_#{parent_table_name}. Indexes are appended # for any more successive uses of the table name. # # Post.find :all, :include => :comments @@ -505,9 +505,9 @@ module ActiveRecord # TreeMixin.find :all, :include => {:children => {:parent => :children}} # # => SELECT ... FROM mixins LEFT OUTER JOIN mixins childrens_mixins ... # LEFT OUTER JOIN parents_mixins ... - # LEFT OUTER JOIN mixins childrens_mixins_2 + # LEFT OUTER JOIN mixins childrens_mixins_2 # - # Has and Belongs to Many join tables use the same idea, but add a _join suffix: + # Has and Belongs to Many join tables use the same idea, but add a _join suffix: # # Post.find :all, :include => :categories # # => SELECT ... FROM posts LEFT OUTER JOIN categories_posts ... LEFT OUTER JOIN categories ... @@ -519,7 +519,7 @@ module ActiveRecord # LEFT OUTER JOIN categories_posts posts_categories_join LEFT OUTER JOIN posts posts_categories # LEFT OUTER JOIN categories_posts categories_posts_join LEFT OUTER JOIN categories categories_posts # - # If you wish to specify your own custom joins using a :joins option, those table names will take precedence over the eager associations.. + # If you wish to specify your own custom joins using a :joins option, those table names will take precedence over the eager associations: # # Post.find :all, :include => :comments, :joins => "inner join comments ..." # # => SELECT ... FROM posts LEFT OUTER JOIN comments_posts ON ... INNER JOIN comments ... @@ -544,8 +544,8 @@ module ActiveRecord # end # end # - # When Firm#clients is called, it'll in turn call MyApplication::Business::Company.find(firm.id). If you want to associate - # with a class in another module scope this can be done by specifying the complete class name, such as: + # When Firm#clients is called, it will in turn call MyApplication::Business::Company.find(firm.id). If you want to associate + # with a class in another module scope, this can be done by specifying the complete class name. Example: # # module MyApplication # module Business @@ -559,41 +559,41 @@ module ActiveRecord # end # end # - # == Type safety with ActiveRecord::AssociationTypeMismatch + # == Type safety with ActiveRecord::AssociationTypeMismatch # # If you attempt to assign an object to an association that doesn't match the inferred or specified :class_name, you'll - # get a ActiveRecord::AssociationTypeMismatch. + # get an ActiveRecord::AssociationTypeMismatch. # # == Options # - # All of the association macros can be specialized through options which makes more complex cases than the simple and guessable ones + # All of the association macros can be specialized through options. This makes cases more complex than the simple and guessable ones # possible. module ClassMethods - # Adds the following methods for retrieval 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 # has_many :clients would add among others clients.empty?. # * collection(force_reload = false) - returns an array of all the associated objects. # An empty array is returned if none are found. # * collection<<(object, ...) - adds one or more objects to the collection by setting their foreign keys to the collection's primary key. # * collection.delete(object, ...) - removes one or more objects from the collection by setting their foreign keys to NULL. - # This will also destroy the objects if they're declared as belongs_to and dependent on this model. + # This will also destroy the objects if they're declared as +belongs_to+ and dependent on this model. # * collection=objects - replaces the collections content by deleting and adding objects as appropriate. - # * collection_singular_ids - returns an array of the associated objects ids + # * collection_singular_ids - returns an array of the associated objects' ids # * collection_singular_ids=ids - replace the collection by the objects identified by the primary keys in +ids+ # * collection.clear - removes every object from the collection. This destroys the associated objects if they # are associated with :dependent => :destroy, deletes them directly from the database if :dependent => :delete_all, - # and sets their foreign keys to NULL otherwise. - # * collection.empty? - returns true if there are no associated objects. + # or otherwise sets their foreign keys to NULL. + # * collection.empty? - returns +true+ if there are no associated objects. # * collection.size - returns the number of associated objects. # * collection.find - finds an associated object according to the same rules as Base.find. # * collection.build(attributes = {}, ...) - returns one or more new objects of the collection type that have been instantiated - # with +attributes+ and linked to this object through a foreign key but have not yet been saved. *Note:* This only works if an - # associated object already exists, not if it's nil! + # with +attributes+ and linked to this object through a foreign key, but have not yet been saved. *Note:* This only works if an + # associated object already exists, not if it's +nil+! # * collection.create(attributes = {}) - 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 it's nil! + # with +attributes+, 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 it's +nil+! # - # Example: A Firm class declares has_many :clients, which will add: + # Example: A +Firm+ class declares has_many :clients, which will add: # * Firm#clients (similar to Clients.find :all, :conditions => "firm_id = #{id}") # * Firm#clients<< # * Firm#clients.delete @@ -612,47 +612,47 @@ module ActiveRecord # * :class_name - specify the class name of the association. Use it only if that name can't be inferred # from the association name. So has_many :products will by default be linked to the +Product+ class, but # if the real class name is +SpecialProduct+, you'll have to specify it with this option. - # * :conditions - specify the conditions that the associated objects must meet in order to be included as a "WHERE" - # sql fragment, such as "price > 5 AND name LIKE 'B%'". - # * :order - specify the order in which the associated objects are returned as a "ORDER BY" sql fragment, - # such as "last_name, first_name DESC" - # * :group - specify the attribute by which the associated objects are returned as a "GROUP BY" sql fragment, - # such as "category" + # * :conditions - specify the conditions that the associated objects must meet in order to be included as a +WHERE+ + # SQL fragment, such as price > 5 AND name LIKE 'B%'. + # * :order - specify the order in which the associated objects are returned as an ORDER BY SQL fragment, + # such as last_name, first_name DESC + # * :group - specify the attribute by which the associated objects are returned as a GROUP BY SQL fragment, + # such as +category+ # * :foreign_key - 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. - # * :dependent - if set to :destroy all the associated objects are destroyed - # alongside this object by calling their destroy method. If set to :delete_all all associated - # objects are deleted *without* calling their destroy method. If set to :nullify all associated - # objects' foreign keys are set to NULL *without* calling their save callbacks. - # NOTE: :dependent => true is deprecated and has been replaced with :dependent => :destroy. - # May not be set if :exclusively_dependent is also set. - # * :exclusively_dependent - Deprecated; equivalent to :dependent => :delete_all. 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 - # 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. + # 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+. + # * :dependent - if set to :destroy all the associated objects are destroyed + # alongside this object by calling their destroy method. If set to :delete_all all associated + # objects are deleted *without* calling their destroy method. If set to :nullify all associated + # objects' foreign keys are set to +NULL+ *without* calling their save callbacks. + # NOTE: :dependent => true is deprecated and has been replaced with :dependent => :destroy. + # May not be set if :exclusively_dependent is also set. + # * :exclusively_dependent - Deprecated; equivalent to :dependent => :delete_all. If set to +true+ all + # the associated objects 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 + # 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. # * :finder_sql - specify a complete SQL statement to fetch the association. This is a good way to go for complex # associations that depend on multiple tables. Note: When this option is used, +find_in_collection+ is _not_ added. - # * :counter_sql - 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. - # * :extend - specify a named module for extending the proxy, see "Association extensions". + # * :counter_sql - 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. + # * :extend - specify a named module for extending the proxy. See "Association extensions". # * :include - specify second-order associations that should be eager loaded when the collection is loaded. - # * :group: An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause. + # * :group: An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause. # * :limit: An integer determining the limit on the number of rows that should be returned. # * :offset: An integer determining the offset from where the rows should be fetched. So at 5, it would skip the first 4 rows. - # * :select: By default, this is * as in SELECT * FROM, but can be changed if you for example want to do a join, but not - # include the joined columns. - # * :as: Specifies a polymorphic interface (See #belongs_to). - # * :through: Specifies a Join Model to perform the query through. Options for :class_name and :foreign_key + # * :select: By default, this is * as in SELECT * FROM, but can be changed if you for example want to do a join, + # but not include the joined columns. + # * :as: Specifies a polymorphic interface (See #belongs_to). + # * :through: Specifies a Join Model through which to perform the query. Options for :class_name and :foreign_key # are ignored, as the association uses the source reflection. You can only use a :through query through a belongs_to # or has_many association on the join model. # * :source: Specifies the source association name used by has_many :through queries. Only use it if the name cannot be - # inferred from the association. has_many :subscribers, :through => :subscriptions will look for either +:subscribers+ or - # +:subscriber+ on +Subscription+, unless a +:source+ is given. - # * :source_type: Specifies type of the source association used by has_many :through queries where the source association - # is a polymorphic belongs_to. - # * :uniq - if set to true, duplicates will be omitted from the collection. Useful in conjunction with :through. + # inferred from the association. has_many :subscribers, :through => :subscriptions will look for either :subscribers or + # :subscriber on +Subscription+, unless a :source is given. + # * :source_type: Specifies type of the source association used by has_many :through queries where the source + # association is a polymorphic +belongs_to+. + # * :uniq - if set to +true+, duplicates will be omitted from the collection. Useful in conjunction with :through. # # Option examples: # has_many :comments, :order => "posted_on" @@ -684,18 +684,18 @@ module ActiveRecord add_deprecated_api_for_has_many(reflection.name) end - # Adds the following methods for retrieval 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 # has_one :manager would add among others manager.nil?. - # * association(force_reload = false) - returns the associated object. Nil is returned if none is found. + # * association(force_reload = false) - returns the associated object. +nil+ is returned if none is found. # * association=(associate) - assigns the associate object, extracts the primary key, sets it as the foreign key, # and saves the associate object. - # * association.nil? - returns true if there is no associated object. + # * association.nil? - returns +true+ if there is no associated object. # * build_association(attributes = {}) - returns a new object of the associated 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 association already exists. It will NOT work if the association is nil. + # with +attributes+ and linked to this object through a foreign key, but has not yet been saved. Note: This ONLY works if + # an association already exists. It will NOT work if the association is +nil+. # * create_association(attributes = {}) - returns a new object of the associated 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). + # with +attributes+, linked to this object through a foreign key, and that has already been saved (if it passed the validation). # # Example: An Account class declares has_one :beneficiary, which will add: # * Account#beneficiary (similar to Beneficiary.find(:first, :conditions => "account_id = #{id}")) @@ -710,18 +710,18 @@ module ActiveRecord # * :class_name - specify the class name of the association. Use it only if that name can't be inferred # from the association name. So has_one :manager will by default be linked to the +Manager+ class, but # if the real class name is +Person+, you'll have to specify it with this option. - # * :conditions - specify the conditions that the associated object must meet in order to be included as a "WHERE" - # sql fragment, such as "rank = 5". + # * :conditions - specify the conditions that the associated object must meet in order to be included as a +WHERE+ + # SQL fragment, such as rank = 5. # * :order - 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" - # * :dependent - if set to :destroy (or true) the associated object is destroyed when this object is. If set to - # :delete the associated object is deleted *without* calling its destroy method. If set to :nullify the associated - # object's foreign key is set to NULL. Also, association is assigned. + # an ORDER BY SQL fragment, such as last_name, first_name DESC + # * :dependent - if set to :destroy (or +true+), the associated object is destroyed when this object is. If set to + # :delete, the associated object is deleted *without* calling its destroy method. If set to :nullify, the associated + # object's foreign key is set to +NULL+. Also, association is assigned. # * :foreign_key - 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. + # 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+. # * :include - specify second-order associations that should be eager loaded when this object is loaded. - # * :as: Specifies a polymorphic interface (See #belongs_to). + # * :as: Specifies a polymorphic interface (See #belongs_to). # # Option examples: # has_one :credit_card, :dependent => :destroy # destroys the associated credit card @@ -753,16 +753,16 @@ module ActiveRecord deprecated_association_comparison_method(reflection.name, reflection.class_name) end - # Adds the following methods for retrieval 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 for which this object holds an id: # +association+ is replaced with the symbol passed as the first argument, so # belongs_to :author would add among others author.nil?. - # * association(force_reload = false) - returns the associated object. Nil is returned if none is found. + # * association(force_reload = false) - returns the associated object. +nil+ is returned if none is found. # * association=(associate) - assigns the associate object, extracts the primary key, and sets it as the foreign key. - # * association.nil? - returns true if there is no associated object. + # * association.nil? - returns +true+ if there is no associated object. # * build_association(attributes = {}) - returns a new object of the associated type that has been instantiated - # with +attributes+ and linked to this object through a foreign key but has not yet been saved. + # with +attributes+ and linked to this object through a foreign key, but has not yet been saved. # * create_association(attributes = {}) - returns a new object of the associated 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). + # with +attributes+, linked to this object through a foreign key, and that has already been saved (if it passed the validation). # # Example: A Post class declares belongs_to :author, which will add: # * Post#author (similar to Author.find(author_id)) @@ -777,20 +777,20 @@ module ActiveRecord # * :class_name - specify the class name of the association. Use it only if that name can't be inferred # from the association name. So has_one :author will by default be linked to the +Author+ class, but # if the real class name is +Person+, you'll have to specify it with this option. - # * :conditions - specify the conditions that the associated object must meet in order to be included as a "WHERE" - # sql fragment, such as "authorized = 1". + # * :conditions - specify the conditions that the associated object must meet in order to be included as a +WHERE+ + # SQL fragment, such as authorized = 1. # * :order - 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" + # an ORDER BY SQL fragment, such as last_name, first_name DESC # * :foreign_key - specify the 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 a +Person+ class that makes a belongs_to association to a - # +Boss+ class will use "boss_id" as the default foreign_key. - # * :counter_cache - caches the number of belonging objects on the associate class through use of increment_counter - # 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). You can also specify a custom counter cache column by given that - # name instead of a true/false value to this option (e.g., :counter_cache => :my_custom_counter.) + # of the associated class in lower-case and +_id+ suffixed. So a +Person+ class that makes a +belongs_to+ association to a + # +Boss+ class will use +boss_id+ as the default +foreign_key+. + # * :counter_cache - caches the number of belonging objects on the associate class through use of +increment_counter+ + # 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). You can also specify a custom counter cache column by providing + # a column name instead of a +true+/+false+ value to this option (e.g., :counter_cache => :my_custom_counter.) # * :include - specify second-order associations that should be eager loaded when this object is loaded. - # * :polymorphic - specify this association is a polymorphic association by passing true. + # * :polymorphic - specify this association is a polymorphic association by passing +true+. # # Option examples: # belongs_to :firm, :foreign_key => "client_of" @@ -863,8 +863,8 @@ module ActiveRecord end # Associates two classes via an intermediate join table. Unless the join table is explicitly specified as - # an option, it is guessed using the lexical order of the class names. So a join between Developer and Project - # will give the default join table name of "developers_projects" because "D" outranks "P". Note that this precedence + # an option, it is guessed using the lexical order of the class names. So a join between +Developer+ and +Project+ + # will give the default join table name of +developers_projects+ because "D" outranks "P". Note that this precedence # is calculated using the < operator for String. This means that if the strings are of different lengths, # and the strings are equal when compared up to the shortest length, then the longer string is considered of higher # lexical precedence than the shorter one. For example, one would expect the tables paper_boxes and papers @@ -873,37 +873,37 @@ module ActiveRecord # custom join_table option if you need to. # # Deprecated: Any additional fields added to the join table will be placed as attributes when pulling records out through - # has_and_belongs_to_many associations. Records returned from join tables with additional attributes will be marked as - # ReadOnly (because we can't save changes to the additional attrbutes). It's strongly recommended that you upgrade any + # +has_and_belongs_to_many+ associations. Records returned from join tables with additional attributes will be marked as + # +ReadOnly+ (because we can't save changes to the additional attrbutes). It's strongly recommended that you upgrade any # associations with attributes to a real join model (see introduction). # - # Adds the following methods for retrieval and query. + # Adds the following methods for retrieval and query: # +collection+ is replaced with the symbol passed as the first argument, so # has_and_belongs_to_many :categories would add among others categories.empty?. # * collection(force_reload = false) - returns an array of all the associated objects. - # An empty array is returned if none is found. + # An empty array is returned if none are found. # * collection<<(object, ...) - adds one or more objects to the collection by creating associations in the join table - # (collection.push and collection.concat are aliases to this method). + # (collection.push and collection.concat are aliases to this method). # * collection.push_with_attributes(object, join_attributes) - adds one to the collection by creating an association in the join table that # also holds the attributes from join_attributes (should be a hash with the column names as keys). This can be used to have additional # attributes on the join, which will be injected into the associated objects when they are retrieved through the collection. - # (collection.concat_with_attributes is an alias to this method). This method is now deprecated. + # (collection.concat_with_attributes is an alias to this method). This method is now deprecated. # * collection.delete(object, ...) - removes one or more objects from the collection by removing their associations from the join table. # This does not destroy the objects. - # * collection=objects - replaces the collections content by deleting and adding objects as appropriate. - # * collection_singular_ids - returns an array of the associated objects ids + # * collection=objects - replaces the collection's content by deleting and adding objects as appropriate. + # * collection_singular_ids - returns an array of the associated objects' ids # * collection_singular_ids=ids - replace the collection by the objects identified by the primary keys in +ids+ # * collection.clear - removes every object from the collection. This does not destroy the objects. - # * collection.empty? - returns true if there are no associated objects. + # * collection.empty? - returns +true+ if there are no associated objects. # * collection.size - returns the number of associated objects. # * collection.find(id) - finds an associated object responding to the +id+ and that # meets the condition that it has to be associated with this object. # * collection.build(attributes = {}) - returns a new object of the collection type that has been instantiated - # with +attributes+ and linked to this object through the join table but has not yet been saved. + # with +attributes+ and linked to this object through the join table, but has not yet been saved. # * collection.create(attributes = {}) - returns a new object of the collection type that has been instantiated - # with +attributes+ and linked to this object through the join table and that has already been saved (if it passed the validation). + # with +attributes+, linked to this object through the join table, and that has already been saved (if it passed the validation). # - # Example: An Developer class declares has_and_belongs_to_many :projects, which will add: + # Example: A Developer class declares has_and_belongs_to_many :projects, which will add: # * Developer#projects # * Developer#projects<< # * Developer#projects.delete @@ -923,30 +923,30 @@ module ActiveRecord # from the association name. So has_and_belongs_to_many :projects will by default be linked to the # +Project+ class, but if the real class name is +SuperProject+, you'll have to specify it with this option. # * :join_table - specify the name of the join table if the default based on lexical order isn't what you want. - # WARNING: If you're overwriting the table name of either class, the table_name method MUST be declared underneath any - # has_and_belongs_to_many declaration in order to work. + # WARNING: If you're overwriting the table name of either class, the +table_name+ method MUST be declared underneath any + # +has_and_belongs_to_many+ declaration in order to work. # * :foreign_key - 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_and_belongs_to_many association - # will use "person_id" as the default foreign_key. + # 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+. # * :association_foreign_key - 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 if the associated class is +Project+, - # the has_and_belongs_to_many association will use "project_id" as the default association foreign_key. - # * :conditions - specify the conditions that the associated object must meet in order to be included as a "WHERE" - # sql fragment, such as "authorized = 1". - # * :order - specify the order in which the associated objects are returned as a "ORDER BY" sql fragment, such as "last_name, first_name DESC" - # * :uniq - if set to true, duplicate associated objects will be ignored by accessors and query methods - # * :finder_sql - overwrite the default generated SQL used to fetch the association with a manual one - # * :delete_sql - overwrite the default generated SQL used to remove links between the associated - # classes with a manual one - # * :insert_sql - overwrite the default generated SQL used to add links between the associated classes - # with a manual one + # 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+. + # * :conditions - specify the conditions that the associated object must meet in order to be included as a +WHERE+ + # SQL fragment, such as authorized = 1. + # * :order - specify the order in which the associated objects are returned as a ORDER BY SQL fragment, such as last_name, first_name DESC + # * :uniq - if set to +true+, duplicate associated objects will be ignored by accessors and query methods + # * :finder_sql - overwrite the default generated SQL statement used to fetch the association with a manual statement + # * :delete_sql - overwrite the default generated SQL statement used to remove links between the associated + # classes with a manual statement + # * :insert_sql - overwrite the default generated SQL statement used to add links between the associated classes + # with a manual statement # * :extend - anonymous module for extending the proxy, see "Association extensions". # * :include - specify second-order associations that should be eager loaded when the collection is loaded. - # * :group: An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause. + # * :group: An attribute name by which the result should be grouped. Uses the GROUP BY SQL-clause. # * :limit: An integer determining the limit on the number of rows that should be returned. # * :offset: An integer determining the offset from where the rows should be fetched. So at 5, it would skip the first 4 rows. - # * :select: By default, this is * as in SELECT * FROM, but can be changed if you for example want to do a join, but not - # include the joined columns. + # * :select: By default, this is * as in SELECT * FROM, but can be changed if, for example, you want to do a join + # but not include the joined columns. # # Option examples: # has_and_belongs_to_many :projects diff --git a/activerecord/lib/active_record/associations/association_collection.rb b/activerecord/lib/active_record/associations/association_collection.rb index 4da3f15abe..b0be44ff42 100644 --- a/activerecord/lib/active_record/associations/association_collection.rb +++ b/activerecord/lib/active_record/associations/association_collection.rb @@ -65,7 +65,7 @@ module ActiveRecord # Removes all records from this association. Returns +self+ so method calls may be chained. def clear - return self if length.zero? # forces load_target if hasn't happened already + return self if length.zero? # forces load_target if it hasn't happened already if @reflection.options[:dependent] && @reflection.options[:dependent] == :delete_all destroy_all diff --git a/activerecord/lib/active_record/associations/association_proxy.rb b/activerecord/lib/active_record/associations/association_proxy.rb index 1fe1fee748..d2478fc84e 100644 --- a/activerecord/lib/active_record/associations/association_proxy.rb +++ b/activerecord/lib/active_record/associations/association_proxy.rb @@ -139,7 +139,7 @@ module ActiveRecord end # Can be overwritten by associations that might have the foreign key available for an association without - # having the object itself (and still being a new record). Currently, only belongs_to present this scenario. + # having the object itself (and still being a new record). Currently, only belongs_to presents this scenario. def foreign_key_present false end diff --git a/activerecord/lib/active_record/associations/has_and_belongs_to_many_association.rb b/activerecord/lib/active_record/associations/has_and_belongs_to_many_association.rb index aebe521ca0..917a7fa5e1 100644 --- a/activerecord/lib/active_record/associations/has_and_belongs_to_many_association.rb +++ b/activerecord/lib/active_record/associations/has_and_belongs_to_many_association.rb @@ -14,7 +14,7 @@ module ActiveRecord end def create(attributes = {}) - # Can't use Base.create since the foreign key may be a protected attribute. + # Can't use Base.create because the foreign key may be a protected attribute. if attributes.is_a?(Array) attributes.collect { |attr| create(attr) } else @@ -138,8 +138,8 @@ module ActiveRecord end # Join tables with additional columns on top of the two foreign keys must be considered ambigious unless a select - # clause has been explicitly defined. Otherwise you can get broken records back, if, say, the join column also has - # and id column, which will then overwrite the id column of the records coming back. + # clause has been explicitly defined. Otherwise you can get broken records back, if, for example, the join column also has + # an id column. This will then overwrite the id column of the records coming back. def finding_with_ambigious_select?(select_clause) !select_clause && @owner.connection.columns(@reflection.options[:join_table], "Join Table Columns").size != 2 end diff --git a/activerecord/lib/active_record/associations/has_many_through_association.rb b/activerecord/lib/active_record/associations/has_many_through_association.rb index ec093548da..de0d7cc8a9 100644 --- a/activerecord/lib/active_record/associations/has_many_through_association.rb +++ b/activerecord/lib/active_record/associations/has_many_through_association.rb @@ -67,7 +67,7 @@ module ActiveRecord [:push, :concat].each { |method| alias_method method, :<< } - # Remove +records+ from this association. Does not destroy +records+. + # Removes +records+ from this association. Does not destroy +records+. def delete(*records) records = flatten_deeper(records) records.each { |associate| raise_on_type_mismatch(associate) } diff --git a/activerecord/lib/active_record/associations/has_one_association.rb b/activerecord/lib/active_record/associations/has_one_association.rb index 59e5486ad6..085de27cd5 100644 --- a/activerecord/lib/active_record/associations/has_one_association.rb +++ b/activerecord/lib/active_record/associations/has_one_association.rb @@ -76,7 +76,7 @@ module ActiveRecord end def new_record(replace_existing) - # make sure we load the target first, if we plan on replacing the existing + # Make sure we load the target first, if we plan on replacing the existing # instance. Otherwise, if the target has not previously been loaded # elsewhere, the instance we create will get orphaned. load_target if replace_existing diff --git a/activerecord/lib/active_record/callbacks.rb b/activerecord/lib/active_record/callbacks.rb index 7a19dcb746..83c54680b5 100755 --- a/activerecord/lib/active_record/callbacks.rb +++ b/activerecord/lib/active_record/callbacks.rb @@ -1,25 +1,25 @@ require 'observer' module ActiveRecord - # Callbacks are hooks into the lifecycle of an Active Record object that allows you to trigger logic + # Callbacks are hooks into the lifecycle of an Active Record object that allow you to trigger logic # before or after an alteration of the object state. This can be used to make sure that associated and - # dependent objects are deleted when destroy is called (by overwriting before_destroy) or to massage attributes - # before they're validated (by overwriting before_validation). As an example of the callbacks initiated, consider - # the Base#save call: - # - # * (-) save - # * (-) valid? - # * (1) before_validation - # * (2) before_validation_on_create - # * (-) validate - # * (-) validate_on_create - # * (3) after_validation - # * (4) after_validation_on_create - # * (5) before_save - # * (6) before_create - # * (-) create - # * (7) after_create - # * (8) after_save + # dependent objects are deleted when destroy is called (by overwriting +before_destroy+) or to massage attributes + # before they're validated (by overwriting +before_validation+). As an example of the callbacks initiated, consider + # the Base#save call: + # + # * (-) save + # * (-) valid + # * (1) before_validation + # * (2) before_validation_on_create + # * (-) validate + # * (-) validate_on_create + # * (3) after_validation + # * (4) after_validation_on_create + # * (5) before_save + # * (6) before_create + # * (-) create + # * (7) after_create + # * (8) after_save # # That's a total of eight callbacks, which gives you immense power to react and prepare for each state in the # Active Record lifecycle. @@ -62,8 +62,8 @@ module ActiveRecord # before_destroy :destroy_readers # end # - # Now, when Topic#destroy is run only +destroy_author+ is called. When Reply#destroy is run both +destroy_author+ and - # +destroy_readers+ is called. Contrast this to the situation where we've implemented the save behavior through overwriteable + # Now, when Topic#destroy is run only +destroy_author+ is called. When Reply#destroy is run, both +destroy_author+ and + # +destroy_readers+ are called. Contrast this to the situation where we've implemented the save behavior through overwriteable # methods: # # class Topic < ActiveRecord::Base @@ -74,9 +74,9 @@ module ActiveRecord # def before_destroy() destroy_readers end # end # - # In that case, Reply#destroy would only run +destroy_readers+ and _not_ +destroy_author+. So use the callback macros when - # you want to ensure that a certain callback is called for the entire hierarchy and the regular overwriteable methods when you - # want to leave it up to each descendent to decide whether they want to call +super+ and trigger the inherited callbacks. + # In that case, Reply#destroy would only run +destroy_readers+ and _not_ +destroy_author+. So, use the callback macros when + # you want to ensure that a certain callback is called for the entire hierarchy, and use the regular overwriteable methods + # when you want to leave it up to each descendent to decide whether they want to call +super+ and trigger the inherited callbacks. # # *IMPORTANT:* In order for inheritance to work for the callback queues, you must specify the callbacks before specifying the # associations. Otherwise, you might trigger the loading of a child before the parent has registered the callbacks and they won't @@ -143,7 +143,7 @@ module ActiveRecord # before_destroy 'self.class.delete_all "parent_id = #{id}"' # end # - # Notice that single plings (') are used so the #{id} part isn't evaluated until the callback is triggered. Also note that these + # Notice that single plings (') are used so the #{id} part isn't evaluated until the callback is triggered. Also note that these # inline callbacks can be stacked just like the regular ones: # # class Topic < ActiveRecord::Base @@ -151,23 +151,23 @@ module ActiveRecord # 'puts "Evaluated after parents are destroyed"' # end # - # == The after_find and after_initialize exceptions + # == The +after_find+ and +after_initialize+ exceptions # - # Because after_find and after_initialize are called for each object found and instantiated by a finder, such as Base.find(:all), we've had - # to implement a simple performance constraint (50% more speed on a simple test case). Unlike all the other callbacks, after_find and - # after_initialize will only be run if an explicit implementation is defined (def after_find). In that case, all of the + # Because +after_find+ and +after_initialize+ are called for each object found and instantiated by a finder, such as Base.find(:all), we've had + # to implement a simple performance constraint (50% more speed on a simple test case). Unlike all the other callbacks, +after_find+ and + # +after_initialize+ will only be run if an explicit implementation is defined (def after_find). In that case, all of the # callback types will be called. # - # == before_validation* returning statements + # == before_validation* returning statements # - # If the returning value of a before_validation callback can be evaluated to false, the process will be aborted and Base#save will return false. - # If Base#save! is called it will raise a RecordNotSave error. + # If the returning value of a +before_validation+ callback can be evaluated to +false+, the process will be aborted and Base#save will return +false+. + # If Base#save! is called it will raise a +RecordNotSave+ exception. # Nothing will be appended to the errors object. # # == Cancelling callbacks # - # If a before_* callback returns false, all the later callbacks and the associated action are cancelled. If an after_* callback returns - # false, all the later callbacks are cancelled. Callbacks are generally run in the order they are defined, with the exception of callbacks + # If a before_* callback returns +false+, all the later callbacks and the associated action are cancelled. If an after_* callback returns + # +false+, all the later callbacks are cancelled. Callbacks are generally run in the order they are defined, with the exception of callbacks # defined as methods on the model, which are called last. module Callbacks CALLBACKS = %w( @@ -215,10 +215,10 @@ module ActiveRecord end end - # Is called when the object was instantiated by one of the finders, like Base.find. + # Is called when the object was instantiated by one of the finders, like Base.find. #def after_find() end - # Is called after the object has been instantiated by a call to Base.new. + # Is called after the object has been instantiated by a call to Base.new. #def after_initialize() end def initialize_with_callbacks(attributes = nil) #:nodoc: @@ -229,10 +229,10 @@ module ActiveRecord end private :initialize_with_callbacks - # Is called _before_ Base.save (regardless of whether it's a create or update save). + # Is called _before_ Base.save (regardless of whether it's a +create+ or +update+ save). def before_save() end - # Is called _after_ Base.save (regardless of whether it's a create or update save). + # Is called _after_ Base.save (regardless of whether it's a +create+ or +update+ save). # # class Contact < ActiveRecord::Base # after_save { logger.info( 'New contact saved!' ) } @@ -246,10 +246,10 @@ module ActiveRecord end private :create_or_update_with_callbacks - # Is called _before_ Base.save on new objects that haven't been saved yet (no record exists). + # Is called _before_ Base.save on new objects that haven't been saved yet (no record exists). def before_create() end - # Is called _after_ Base.save on new objects that haven't been saved yet (no record exists). + # Is called _after_ Base.save on new objects that haven't been saved yet (no record exists). def after_create() end def create_with_callbacks #:nodoc: return false if callback(:before_create) == false @@ -259,10 +259,10 @@ module ActiveRecord end private :create_with_callbacks - # Is called _before_ Base.save on existing objects that have a record. + # Is called _before_ Base.save on existing objects that have a record. def before_update() end - # Is called _after_ Base.save on existing objects that have a record. + # Is called _after_ Base.save on existing objects that have a record. def after_update() end def update_with_callbacks #:nodoc: @@ -273,25 +273,25 @@ module ActiveRecord end private :update_with_callbacks - # Is called _before_ Validations.validate (which is part of the Base.save call). + # Is called _before_ Validations.validate (which is part of the Base.save call). def before_validation() end - # Is called _after_ Validations.validate (which is part of the Base.save call). + # Is called _after_ Validations.validate (which is part of the Base.save call). def after_validation() end - # Is called _before_ Validations.validate (which is part of the Base.save call) on new objects + # Is called _before_ Validations.validate (which is part of the Base.save call) on new objects # that haven't been saved yet (no record exists). def before_validation_on_create() end - # Is called _after_ Validations.validate (which is part of the Base.save call) on new objects + # Is called _after_ Validations.validate (which is part of the Base.save call) on new objects # that haven't been saved yet (no record exists). def after_validation_on_create() end - # Is called _before_ Validations.validate (which is part of the Base.save call) on + # Is called _before_ Validations.validate (which is part of the Base.save call) on # existing objects that have a record. def before_validation_on_update() end - # Is called _after_ Validations.validate (which is part of the Base.save call) on + # Is called _after_ Validations.validate (which is part of the Base.save call) on # existing objects that have a record. def after_validation_on_update() end @@ -308,13 +308,13 @@ module ActiveRecord return result end - # Is called _before_ Base.destroy. + # Is called _before_ Base.destroy. # # Note: If you need to _destroy_ or _nullify_ associated records first, - # use the _:dependent_ option on your associations. + # use the :dependent option on your associations. def before_destroy() end - # Is called _after_ Base.destroy (and all the attributes have been frozen). + # Is called _after_ Base.destroy (and all the attributes have been frozen). # # class Contact < ActiveRecord::Base # after_destroy { |record| logger.info( "Contact #{record.id} was destroyed." ) } -- cgit v1.2.3