activemodel 3.0.0.beta4 → 3.0.pre

data/CHANGELOG

@@ -1,42 +1,4 @@
-*Rails 3.0.0 [beta 4] (June 8th, 2010)*
-
-* JSON supports a custom root option: to_json(:root => 'custom')  #4515 [Jatinder Singh]
-
-
-*Rails 3.0.0 [beta 3] (April 13th, 2010)*
-
-* No changes
-
-
-*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 
-  not destroyed? [MG]
-
-* Added validations reflection in ActiveModel::Validations [JV]
-
-    Model.validators
-    Model.validators_on(:field)
-
-* #to_key was added to ActiveModel::Lint so we can generate DOM IDs for
-  AMo objects with composite keys [MG]
-
-
-*Rails 3.0.0 [beta 1] (February 4, 2010)*
-
-* ActiveModel::Observer#add_observer!
-
-  It has a custom hook to define after_find that should really be in a
-  ActiveRecord::Observer subclass:
-
-	  def add_observer!(klass)
-	    klass.add_observer(self)
-	    klass.class_eval 'def after_find() end' unless
-				klass.respond_to?(:after_find)
-	  end
-
-* Change the ActiveModel::Base.include_root_in_json default to true for Rails 3 [DHH]
+*Edge*
 
 * Add validates_format_of :without => /regexp/ option. #430 [Elliot Winkler, Peer Allan]
 

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2004-2010 David Heinemeier Hansson
+Copyright (c) 2004-2009 David Heinemeier Hansson
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README

@@ -1,205 +1,21 @@
-= Active Model - defined interfaces for Rails
- 
-Prior to Rails 3.0, if a plugin or gem developer wanted to be able to have
-an object interact with Action Pack helpers, it was required to either
-copy chunks of code from Rails, or monkey patch entire helpers to make them
-handle objects that did not look like Active Record.  This generated code
-duplication and fragile applications that broke on upgrades.
- 
-Active Model is a solution for this problem.
- 
-Active Model provides a known set of interfaces that your objects can implement
-to then present a common interface to the Action Pack helpers.  You can include
-functionality from the following modules:
+Active Model
+==============
 
-* Adding attribute magic to your objects
+Totally experimental library that aims to extract common model mixins from
+ActiveRecord for use in ActiveResource (and other similar libraries).  
+This is in a very rough state (no autotest or spec rake tasks set up yet),
+so please excuse the mess.  
 
-    Add prefixes and suffixes to defined attribute methods...
-    
-    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
-    
-    ...gives you clear_name, clear_age.
-  
-  {Learn more}[link:classes/ActiveModel/AttributeMethods.html]
-  
-* Adding callbacks to your objects
+Here's what I plan to extract:
+  * ActiveModel::Observing 
+  * ActiveModel::Callbacks
+  * ActiveModel::Validations
 
-    class Person
-      extend ActiveModel::Callbacks
-      define_model_callbacks :create
-    
-      def create
-        _run_create_callbacks do
-          # Your create action methods here
-        end
-      end
-    end
-    
-    ...gives you before_create, around_create and after_create class methods that
-    wrap your create method.
-   
-  {Learn more}[link:classes/ActiveModel/CallBacks.html]
+	# for ActiveResource params and ActiveRecord options
+  * ActiveModel::Scoping
 
-* For classes that already look like an Active Record object
+	# to_json, to_xml, etc
+  * ActiveModel::Serialization
 
-    class Person
-      include ActiveModel::Conversion
-    end
-    
-    ...returns the class itself when sent :to_model
-
-   {Learn more}[link:classes/ActiveModel/Conversion.html]
-
-* Tracking changes in your object
-
-    Provides all the value tracking features implemented by ActiveRecord...
-    
-    person = Person.new
-    person.name # => nil
-    person.changed? # => false
-    person.name = 'bob'
-    person.changed? # => true
-    person.changed # => ['name']
-    person.changes # => { 'name' => [nil, 'bob'] }
-    person.name = 'robert'
-    person.save
-    person.previous_changes # => {'name' => ['bob, 'robert']}
- 
-  {Learn more}[link:classes/ActiveModel/Dirty.html]
-
-* Adding +errors+ support to your object
-
-    Provides the error messages to allow your object 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
-    
-    ... gives you...
-    
-    person.errors.full_messages
-    # => ["Name Can not be nil"]
-    person.errors.full_messages
-    # => ["Name Can not be nil"]
-
-  {Learn more}[link:classes/ActiveModel/Errors.html]
-
-* Testing the compliance of your object
-
-    Use ActiveModel::Lint to test the compliance of your object to the
-    basic ActiveModel API...
-    
-  {Learn more}[link:classes/ActiveModel/Lint/Tests.html]
-
-* Providing a human face to your object
-
-    ActiveModel::Naming provides your model with the model_name convention
-    and a human_name attribute...
-    
-    class NamedPerson
-      extend ActiveModel::Naming
-    end
-    
-    ...gives you...
-    
-    NamedPerson.model_name        #=> "NamedPerson"
-    NamedPerson.model_name.human  #=> "Named person"
-
-  {Learn more}[link:classes/ActiveModel/Naming.html]
-
-* Adding observer support to your objects
-
-    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 your object 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]
-
-* Integrating with Rail's internationalization (i18n) handling through
-  ActiveModel::Translations...
-
-    class Person
-      extend ActiveModel::Translation
-    end
-  
-  {Learn more}[link:classes/ActiveModel/Translation.html]
-
-* Providing a full Validation stack for your objects...
-
-   class Person
-     include ActiveModel::Validations
-
-     attr_accessor :first_name, :last_name
-
-
-     validates_each :first_name, :last_name do |record, attr, value|
-       record.errors.add attr, 'starts with z.' if value.to_s[0] == ?z
-     end
-   end
-
-
-   person = Person.new(:first_name => 'zoolander')
-   person.valid?          #=> false
-
-  {Learn more}[link:classes/ActiveModel/Validations.html]
-  
-* Make custom validators
-
-   class Person
-     include ActiveModel::Validations
-     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.name = "Bob"
-   p.valid?                  #=>  true
-
-  {Learn more}[link:classes/ActiveModel/Validator.html]
+I'm trying to keep ActiveRecord compatibility where possible, but I'm
+annotating the spots where I'm diverging a bit.

data/lib/active_model.rb

@@ -1,5 +1,5 @@
 #--
-# Copyright (c) 2004-2010 David Heinemeier Hansson
+# Copyright (c) 2004-2009 David Heinemeier Hansson
 #
 # Permission is hereby granted, free of charge, to any person obtaining
 # a copy of this software and associated documentation files (the
@@ -21,41 +21,32 @@
 # WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 #++
 
-activesupport_path = File.expand_path('../../../activesupport/lib', __FILE__)
-$:.unshift(activesupport_path) if File.directory?(activesupport_path) && !$:.include?(activesupport_path)
+activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
+$:.unshift(activesupport_path) if File.directory?(activesupport_path)
 require 'active_support'
 
-
 module ActiveModel
-  extend ActiveSupport::Autoload
-
-  autoload :AttributeMethods
-  autoload :BlockValidator, 'active_model/validator'
-  autoload :Callbacks
-  autoload :Conversion
-  autoload :DeprecatedErrorMethods
-  autoload :Dirty
-  autoload :EachValidator, 'active_model/validator'
-  autoload :Errors
-  autoload :Lint
+  autoload :AttributeMethods, 'active_model/attribute_methods'
+  autoload :Conversion, 'active_model/conversion'
+  autoload :DeprecatedErrorMethods, 'active_model/deprecated_error_methods'
+  autoload :Dirty, 'active_model/dirty'
+  autoload :Errors, 'active_model/errors'
+  autoload :Lint, 'active_model/lint'
   autoload :Name, 'active_model/naming'
-  autoload :Naming
+  autoload :Naming, 'active_model/naming'
   autoload :Observer, 'active_model/observing'
-  autoload :Observing
-  autoload :Serialization
-  autoload :TestCase
-  autoload :Translation
-  autoload :VERSION
-  autoload :Validations
-  autoload :Validator
+  autoload :Observing, 'active_model/observing'
+  autoload :Serialization, 'active_model/serialization'
+  autoload :StateMachine, 'active_model/state_machine'
+  autoload :TestCase, 'active_model/test_case'
+  autoload :Validations, 'active_model/validations'
+  autoload :ValidationsRepairHelper, 'active_model/validations_repair_helper'
+  autoload :VERSION, 'active_model/version'
 
   module Serializers
-    extend ActiveSupport::Autoload
-
-    autoload :JSON
-    autoload :Xml
+    autoload :JSON, 'active_model/serializers/json'
+    autoload :Xml, 'active_model/serializers/xml'
   end
 end
 
-require 'active_support/i18n'
 I18n.load_path << File.dirname(__FILE__) + '/active_model/locale/en.yml'

data/lib/active_model/attribute_methods.rb

@@ -5,54 +5,10 @@ module ActiveModel
   class MissingAttributeError < NoMethodError
   end
 
-  # <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:
-  #
-  # * <tt>include ActiveModel::AttributeMethods</tt> in your object
-  # * 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
-  #
-  # Please notice that whenever you include ActiveModel::AtributeMethods 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 hash value.
-  # Hash keys must be a string.
-  #
   module AttributeMethods
     extend ActiveSupport::Concern
 
+    # Declare and check for suffixed attribute methods.
     module ClassMethods
       # Defines an "attribute" method (like +inheritance_column+ or
       # +table_name+). A new (class) method will be created with the
@@ -66,43 +22,21 @@ module ActiveModel
       #
       # Example:
       #
-      #   class Person
-      # 
-      #     include ActiveModel::AttributeMethods
-      # 
-      #     cattr_accessor :primary_key
-      #     cattr_accessor :inheritance_column
-      #     
+      #   class A < ActiveRecord::Base
       #     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'
-      #   AttributePerson.inheritance_column
-      #   # => 'address_id'
       def define_attr_method(name, value=nil, &block)
-        sing = singleton_class
-        sing.class_eval <<-eorb, __FILE__, __LINE__ + 1
-          if method_defined?(:original_#{name})
-            undef :original_#{name}
-          end
-          alias_method :original_#{name}, :#{name}
-        eorb
+        sing = metaclass
+        sing.send :alias_method, "original_#{name}", name
         if block_given?
           sing.send :define_method, name, &block
         else
           # use eval instead of a block to work around a memory leak in dev
           # mode in fcgi
-          sing.class_eval <<-eorb, __FILE__, __LINE__ + 1
-            def #{name}; #{value.to_s.inspect}; end
-          eorb
+          sing.class_eval "def #{name}; #{value.to_s.inspect}; end"
         end
       end
 
@@ -120,25 +54,19 @@ module ActiveModel
       #
       # For example:
       #
-      #   class Person
-      # 
-      #     include ActiveModel::AttributeMethods
-      #     attr_accessor :name
+      #   class Person < ActiveRecord::Base
       #     attribute_method_prefix 'clear_'
-      #     define_attribute_methods [:name]
       #
       #     private
-      # 
-      #     def clear_attribute(attr)
-      #       send("#{attr}=", nil)
-      #     end
+      #       def clear_attribute(attr)
+      #         ...
+      #       end
       #   end
       #
-      #   person = Person.new
-      #   person.name = "Bob"
-      #   person.name          # => "Bob"
+      #   person = Person.find(1)
+      #   person.name          # => 'Gem'
       #   person.clear_name
-      #   person.name          # => nil
+      #   person.name          # => ''
       def attribute_method_prefix(*prefixes)
         attribute_method_matchers.concat(prefixes.map { |prefix| AttributeMethodMatcher.new :prefix => prefix })
         undefine_attribute_methods
@@ -158,24 +86,18 @@ module ActiveModel
       #
       # For example:
       #
-      #   class Person
-      # 
-      #     include ActiveModel::AttributeMethods
-      #     attr_accessor :name
+      #   class Person < ActiveRecord::Base
       #     attribute_method_suffix '_short?'
-      #     define_attribute_methods [:name]
       #
       #     private
-      # 
-      #     def attribute_short?(attr)
-      #       send(attr).length < 5
-      #     end
+      #       def attribute_short?(attr)
+      #         ...
+      #       end
       #   end
       #
-      #   person = Person.new
-      #   person.name = "Bob"
-      #   person.name          # => "Bob"
-      #   person.name_short?   # => true
+      #   person = Person.find(1)
+      #   person.name           # => 'Gem'
+      #   person.name_short?    # => true
       def attribute_method_suffix(*suffixes)
         attribute_method_matchers.concat(suffixes.map { |suffix| AttributeMethodMatcher.new :suffix => suffix })
         undefine_attribute_methods
@@ -196,21 +118,16 @@ module ActiveModel
       #
       # For example:
       #
-      #   class Person
-      # 
-      #     include ActiveModel::AttributeMethods
-      #     attr_accessor :name
+      #   class Person < ActiveRecord::Base
       #     attribute_method_affix :prefix => 'reset_', :suffix => '_to_default!'
-      #     define_attribute_methods [:name]
       #
       #     private
-      # 
-      #     def reset_attribute_to_default!(attr)
-      #       ...
-      #     end
+      #       def reset_attribute_to_default!(attr)
+      #         ...
+      #       end
       #   end
       #
-      #   person = Person.new
+      #   person = Person.find(1)
       #   person.name                         # => 'Gem'
       #   person.reset_name_to_default!
       #   person.name                         # => 'Gemma'
@@ -221,7 +138,7 @@ module ActiveModel
 
       def alias_attribute(new_name, old_name)
         attribute_method_matchers.each do |matcher|
-          module_eval <<-STR, __FILE__, __LINE__ + 1
+          module_eval <<-STR, __FILE__, __LINE__+1
             def #{matcher.method_name(new_name)}(*args)
               send(:#{matcher.method_name(old_name)}, *args)
             end
@@ -229,30 +146,6 @@ module ActiveModel
         end
       end
 
-      # 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_'
-      #
-      #     # Call to define_attribute_methods must appear after the
-      #     # attribute_method_prefix, attribute_method_suffix or
-      #     # attribute_method_affix declares.
-      #     define_attribute_methods [:name, :age, :address]
-      #
-      #     private
-      # 
-      #     def clear_attribute(attr)
-      #       ...
-      #     end
-      #   end
       def define_attribute_methods(attr_names)
         return if attribute_methods_generated?
         attr_names.each do |attr_name|
@@ -263,13 +156,8 @@ module ActiveModel
               if respond_to?(generate_method)
                 send(generate_method, attr_name)
               else
-                method_name = matcher.method_name(attr_name)
-
-                generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__ + 1
-                  if method_defined?(:#{method_name})
-                    undef :#{method_name}
-                  end
-                  def #{method_name}(*args)
+                generated_attribute_methods.module_eval <<-STR, __FILE__, __LINE__+1
+                  def #{matcher.method_name(attr_name)}(*args)
                     send(:#{matcher.method_missing_target}, '#{attr_name}', *args)
                   end
                 STR
@@ -280,7 +168,6 @@ module ActiveModel
         @attribute_methods_generated = true
       end
 
-      # Removes all the preiously dynamically defined methods from the class
       def undefine_attribute_methods
         generated_attribute_methods.module_eval do
           instance_methods.each { |m| undef_method(m) }
@@ -288,7 +175,6 @@ module ActiveModel
         @attribute_methods_generated = nil
       end
 
-      # Returns true if the attribute methods defined have been generated.
       def generated_attribute_methods #:nodoc:
         @generated_attribute_methods ||= begin
           mod = Module.new
@@ -297,7 +183,6 @@ module ActiveModel
         end
       end
 
-      # Returns true if the attribute methods defined have been generated.
       def attribute_methods_generated?
         @attribute_methods_generated ||= nil
       end