activemodel 3.0.0.rc → 3.0.0.rc2

data/CHANGELOG

@@ -1,3 +1,8 @@
+*Rails 3.0.0 [release candidate 2] (August 23rd, 2010)*
+
+* No material changes (see http://github.com/rails/rails/compare/v3.0.0_RC...v3.0.0_RC2 for gory details)
+
+
 *Rails 3.0.0 [release candidate] (July 26th, 2010)*
 
 * Added ActiveModel::MassAssignmentSecurity [Eric Chapweske, Josh Kalderimis]
@@ -16,7 +21,7 @@
 *Rails 3.0.0 [beta 2] (April 1st, 2010)*
 
 * #new_record? and #destroyed? were removed from ActiveModel::Lint. Use
-  persisted? instead. A model is persisted if it's not a new_record? and it was 
+  persisted? instead. A model is persisted if it's not a new_record? and it was
   not destroyed? [MG]
 
 * Added validations reflection in ActiveModel::Validations [JV]

data/README.rdoc

@@ -18,38 +18,38 @@ modules:
 
     class Person
       include ActiveModel::AttributeMethods
-      
+
       attribute_method_prefix 'clear_'
       define_attribute_methods [:name, :age]
-      
+
       attr_accessor :name, :age
-      
+
       def clear_attribute(attr)
         send("#{attr}=", nil)
       end
     end
-    
+
     person.clear_name
     person.clear_age
-  
+
   {Learn more}[link:classes/ActiveModel/AttributeMethods.html]
-  
+
 * Callbacks for certain operations
 
     class Person
       extend ActiveModel::Callbacks
       define_model_callbacks :create
-    
+
       def create
         _run_create_callbacks do
           # Your create action methods here
         end
       end
     end
-  
+
   This generates +before_create+, +around_create+ and +after_create+
   class methods that wrap your create method.
-  
+
   {Learn more}[link:classes/ActiveModel/CallBacks.html]
 
 * Tracking value changes
@@ -66,36 +66,36 @@ modules:
     person.name = 'robert'
     person.save
     person.previous_changes # => {'name' => ['bob, 'robert']}
-  
+
   {Learn more}[link:classes/ActiveModel/Dirty.html]
 
 * Adding +errors+ interface to objects
 
   Exposing error messages allows objects to interact with Action Pack
   helpers seamlessly.
-  
+
     class Person
-    
+
       def initialize
         @errors = ActiveModel::Errors.new(self)
       end
-    
+
       attr_accessor :name
       attr_reader   :errors
-    
+
       def validate!
         errors.add(:name, "can not be nil") if name == nil
       end
-    
+
       def ErrorsPerson.human_attribute_name(attr, options = {})
         "Name"
       end
-    
+
     end
-    
+
     person.errors.full_messages
     # => ["Name Can not be nil"]
-    
+
     person.errors.full_messages
     # => ["Name Can not be nil"]
 
@@ -106,9 +106,9 @@ modules:
     class NamedPerson
       extend ActiveModel::Naming
     end
-    
-    NamedPerson.model_name        #=> "NamedPerson"
-    NamedPerson.model_name.human  #=> "Named person"
+
+    NamedPerson.model_name        # => "NamedPerson"
+    NamedPerson.model_name.human  # => "Named person"
 
   {Learn more}[link:classes/ActiveModel/Naming.html]
 
@@ -117,19 +117,19 @@ modules:
   ActiveModel::Observers allows your object to implement the Observer
   pattern in a Rails App and take advantage of all the standard observer
   functions.
-  
+
   {Learn more}[link:classes/ActiveModel/Observer.html]
 
 * Making objects serializable
 
   ActiveModel::Serialization provides a standard interface for your object
   to provide +to_json+ or +to_xml+ serialization.
-  
+
     s = SerialPerson.new
     s.serializable_hash   # => {"name"=>nil}
     s.to_json             # => "{\"name\":null}"
     s.to_xml              # => "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<serial-person...
-  
+
   {Learn more}[link:classes/ActiveModel/Serialization.html]
 
 * Internationalization (i18n) support
@@ -137,10 +137,10 @@ modules:
     class Person
       extend ActiveModel::Translation
     end
-    
+
     Person.human_attribute_name('my_attribute')
-    #=> "My attribute"
-  
+    # => "My attribute"
+
   {Learn more}[link:classes/ActiveModel/Translation.html]
 
 * Validation support
@@ -157,10 +157,10 @@ modules:
 
    person = Person.new
    person.first_name = 'zoolander'
-   person.valid?  #=> false
+   person.valid?  # => false
 
   {Learn more}[link:classes/ActiveModel/Validations.html]
-  
+
 * Custom validators
 
    class Person
@@ -168,17 +168,17 @@ modules:
      validates_with HasNameValidator
      attr_accessor :name
    end
-   
+
    class HasNameValidator < ActiveModel::Validator
      def validate(record)
       record.errors[:name] = "must exist" if record.name.blank?
      end
    end
-   
+
    p = ValidatorPerson.new
-   p.valid?                  #=>  false
-   p.errors.full_messages    #=> ["Name must exist"]
+   p.valid?                  # =>  false
+   p.errors.full_messages    # => ["Name must exist"]
    p.name = "Bob"
-   p.valid?                  #=>  true
+   p.valid?                  # =>  true
 
   {Learn more}[link:classes/ActiveModel/Validator.html]

data/lib/active_model/attribute_methods.rb

@@ -9,46 +9,46 @@ module ActiveModel
   # <tt>ActiveModel::AttributeMethods</tt> provides a way to add prefixes and suffixes
   # to your methods as well as handling the creation of Active Record like class methods
   # such as +table_name+.
-  # 
+  #
   # The requirements to implement ActiveModel::AttributeMethods are to:
   #
   # * <tt>include ActiveModel::AttributeMethods</tt> in your object
-  # * Call each Attribute Method module method you want to add, such as 
+  # * Call each Attribute Method module method you want to add, such as
   #   attribute_method_suffix or attribute_method_prefix
   # * Call <tt>define_attribute_methods</tt> after the other methods are
   #   called.
   # * Define the various generic +_attribute+ methods that you have declared
-  # 
+  #
   # A minimal implementation could be:
-  # 
+  #
   #   class Person
   #     include ActiveModel::AttributeMethods
-  #     
+  #
   #     attribute_method_affix  :prefix => 'reset_', :suffix => '_to_default!'
   #     attribute_method_suffix '_contrived?'
   #     attribute_method_prefix 'clear_'
   #     define_attribute_methods ['name']
-  #     
+  #
   #     attr_accessor :name
-  #     
+  #
   #     private
-  #     
+  #
   #     def attribute_contrived?(attr)
   #       true
   #     end
-  #     
+  #
   #     def clear_attribute(attr)
   #       send("#{attr}=", nil)
   #     end
-  #     
+  #
   #     def reset_attribute_to_default!(attr)
   #       send("#{attr}=", "Default Name")
   #     end
   #   end
   #
   # Notice that whenever you include ActiveModel::AttributeMethods in your class,
-  # it requires you to implement a <tt>attributes</tt> methods which returns a hash 
-  # with each attribute name in your model as hash key and the attribute value as 
+  # it requires you to implement a <tt>attributes</tt> methods which returns a hash
+  # with each attribute name in your model as hash key and the attribute value as
   # hash value.
   #
   # Hash keys must be strings.
@@ -57,34 +57,34 @@ module ActiveModel
     extend ActiveSupport::Concern
 
     module ClassMethods
-      # Defines an "attribute" method (like +inheritance_column+ or +table_name+). 
-      # A new (class) method will be created with the given name. If a value is 
-      # specified, the new method will return that value (as a string). 
-      # Otherwise, the given block will be used to compute the value of the 
+      # Defines an "attribute" method (like +inheritance_column+ or +table_name+).
+      # A new (class) method will be created with the given name. If a value is
+      # specified, the new method will return that value (as a string).
+      # Otherwise, the given block will be used to compute the value of the
       # method.
       #
       # The original method will be aliased, with the new name being prefixed
-      # with "original_". This allows the new method to access the original 
+      # with "original_". This allows the new method to access the original
       # value.
       #
       # Example:
       #
       #   class Person
-      # 
+      #
       #     include ActiveModel::AttributeMethods
-      # 
+      #
       #     cattr_accessor :primary_key
       #     cattr_accessor :inheritance_column
-      #     
+      #
       #     define_attr_method :primary_key, "sysid"
       #     define_attr_method( :inheritance_column ) do
       #       original_inheritance_column + "_id"
       #     end
-      # 
+      #
       #   end
-      # 
+      #
       # Provides you with:
-      # 
+      #
       #   AttributePerson.primary_key
       #   # => "sysid"
       #   AttributePerson.inheritance_column = 'address'
@@ -118,20 +118,20 @@ module ActiveModel
       #
       #   #{prefix}attribute(#{attr}, *args, &block)
       #
-      # An instance method <tt>#{prefix}attribute</tt> must exist and accept 
+      # An instance method <tt>#{prefix}attribute</tt> must exist and accept
       # at least the +attr+ argument.
       #
       # For example:
       #
       #   class Person
-      # 
+      #
       #     include ActiveModel::AttributeMethods
       #     attr_accessor :name
       #     attribute_method_prefix 'clear_'
       #     define_attribute_methods [:name]
       #
       #     private
-      # 
+      #
       #     def clear_attribute(attr)
       #       send("#{attr}=", nil)
       #     end
@@ -162,14 +162,14 @@ module ActiveModel
       # For example:
       #
       #   class Person
-      # 
+      #
       #     include ActiveModel::AttributeMethods
       #     attr_accessor :name
       #     attribute_method_suffix '_short?'
       #     define_attribute_methods [:name]
       #
       #     private
-      # 
+      #
       #     def attribute_short?(attr)
       #       send(attr).length < 5
       #     end
@@ -200,14 +200,14 @@ module ActiveModel
       # For example:
       #
       #   class Person
-      # 
+      #
       #     include ActiveModel::AttributeMethods
       #     attr_accessor :name
       #     attribute_method_affix :prefix => 'reset_', :suffix => '_to_default!'
       #     define_attribute_methods [:name]
       #
       #     private
-      # 
+      #
       #     def reset_attribute_to_default!(attr)
       #       ...
       #     end
@@ -232,15 +232,15 @@ module ActiveModel
         end
       end
 
-      # Declares a the attributes that should be prefixed and suffixed by 
+      # Declares a the attributes that should be prefixed and suffixed by
       # ActiveModel::AttributeMethods.
-      # 
+      #
       # To use, pass in an array of attribute names (as strings or symbols),
       # be sure to declare +define_attribute_methods+ after you define any
       # prefix, suffix or affix methods, or they will not hook in.
-      # 
+      #
       #   class Person
-      # 
+      #
       #     include ActiveModel::AttributeMethods
       #     attr_accessor :name, :age, :address
       #     attribute_method_prefix 'clear_'
@@ -251,7 +251,7 @@ module ActiveModel
       #     define_attribute_methods [:name, :age, :address]
       #
       #     private
-      # 
+      #
       #     def clear_attribute(attr)
       #       ...
       #     end
@@ -283,7 +283,7 @@ module ActiveModel
         @attribute_methods_generated = true
       end
 
-      # Removes all the preiously dynamically defined methods from the class
+      # Removes all the previously dynamically defined methods from the class
       def undefine_attribute_methods
         generated_attribute_methods.module_eval do
           instance_methods.each { |m| undef_method(m) }
@@ -344,16 +344,16 @@ module ActiveModel
         end
     end
 
-    # Allows access to the object attributes, which are held in the 
-    # <tt>@attributes</tt> hash, as though they were first-class methods. So a 
-    # Person class with a name attribute can use Person#name and Person#name= 
+    # Allows access to the object attributes, which are held in the
+    # <tt>@attributes</tt> hash, as though they were first-class methods. So a
+    # Person class with a name attribute can use Person#name and Person#name=
     # and never directly use the attributes hash -- except for multiple assigns
-    # with ActiveRecord#attributes=. A Milestone class can also ask 
-    # Milestone#completed? to test that the completed attribute is not +nil+ 
+    # with ActiveRecord#attributes=. A Milestone class can also ask
+    # Milestone#completed? to test that the completed attribute is not +nil+
     # or 0.
     #
-    # It's also possible to instantiate related objects, so a Client class 
-    # belonging to the clients table with a +master_id+ foreign key can 
+    # It's also possible to instantiate related objects, so a Client class
+    # belonging to the clients table with a +master_id+ foreign key can
     # instantiate master through Client#master.
     def method_missing(method_id, *args, &block)
       method_name = method_id.to_s

data/lib/active_model/callbacks.rb

@@ -3,49 +3,49 @@ require 'active_support/callbacks'
 
 module ActiveModel
   # == Active Model Callbacks
-  # 
+  #
   # Provides an interface for any class to have Active Record like callbacks.
-  # 
+  #
   # Like the Active Record methods, the callback chain is aborted as soon as
   # one of the methods in the chain returns false.
   #
   # First, extend ActiveModel::Callbacks from the class you are creating:
-  # 
+  #
   #   class MyModel
   #     extend ActiveModel::Callbacks
   #   end
-  # 
+  #
   # Then define a list of methods that you want callbacks attached to:
-  # 
+  #
   #   define_model_callbacks :create, :update
-  # 
+  #
   # This will provide all three standard callbacks (before, around and after) for
-  # both the :create and :update methods. To implement, you need to wrap the methods 
+  # both the :create and :update methods. To implement, you need to wrap the methods
   # you want callbacks on in a block so that the callbacks get a chance to fire:
-  # 
+  #
   #   def create
   #     _run_create_callbacks do
   #       # Your create action methods here
   #     end
   #   end
-  # 
+  #
   # The _run_<method_name>_callbacks methods are dynamically created when you extend
   # the <tt>ActiveModel::Callbacks</tt> module.
-  # 
+  #
   # Then in your class, you can use the +before_create+, +after_create+ and +around_create+
   # methods, just as you would in an Active Record module.
-  # 
+  #
   #   before_create :action_before_create
-  # 
+  #
   #   def action_before_create
   #     # Your code here
   #   end
-  # 
-  # You can choose not to have all three callbacks by passing a hash to the 
+  #
+  # You can choose not to have all three callbacks by passing a hash to the
   # define_model_callbacks method.
-  # 
+  #
   #   define_model_callbacks :create, :only => :after, :before
-  # 
+  #
   # Would only create the after_create and before_create callback methods in your
   # class.
   module Callbacks
@@ -56,44 +56,47 @@ module ActiveModel
     end
 
     # define_model_callbacks accepts the same options define_callbacks does, in case
-    # you want to overwrite a default. Besides that, it also accepts an :only option, 
+    # you want to overwrite a default. Besides that, it also accepts an :only option,
     # where you can choose if you want all types (before, around or after) or just some.
     #
     #   define_model_callbacks :initializer, :only => :after
-    # 
+    #
     # Note, the <tt>:only => <type></tt> hash will apply to all callbacks defined on
     # that method call.  To get around this you can call the define_model_callbacks
     # method as many times as you need.
-    # 
+    #
     #   define_model_callbacks :create, :only => :after
     #   define_model_callbacks :update, :only => :before
     #   define_model_callbacks :destroy, :only => :around
-    # 
+    #
     # Would create +after_create+, +before_update+ and +around_destroy+ methods only.
-    # 
+    #
     # You can pass in a class to before_<type>, after_<type> and around_<type>, in which
     # case the callback will call that class's <action>_<type> method passing the object
     # that the callback is being called on.
-    # 
+    #
     #   class MyModel
     #     extend ActiveModel::Callbacks
     #     define_model_callbacks :create
-    # 
+    #
     #     before_create AnotherClass
     #   end
-    # 
+    #
     #   class AnotherClass
     #     def self.before_create( obj )
     #       # obj is the MyModel instance that the callback is being called on
     #     end
     #   end
-    #     
+    #
     def define_model_callbacks(*callbacks)
       options = callbacks.extract_options!
-      options = { :terminator => "result == false", :scope => [:kind, :name] }.merge(options)
+      options = {
+         :terminator => "result == false",
+         :scope => [:kind, :name],
+         :only => [:before, :around, :after]
+      }.merge(options)
 
-      types = Array.wrap(options.delete(:only))
-      types = [:before, :around, :after] if types.empty?
+      types   = Array.wrap(options.delete(:only))
 
       callbacks.each do |callback|
         define_callbacks(callback, options)