activemodel 3.0.0.beta4 → 3.0.pre

data/lib/active_model/conversion.rb

@@ -1,44 +1,8 @@
 module ActiveModel
-  # Handle default conversions: to_model, to_key and to_param.
-  #
-  # == Example
-  #
-  # Let's take for example this non persisted object.
-  #
-  #   class ContactMessage
-  #     include ActiveModel::Conversion
-  #
-  #     # ContactMessage are never persisted in the DB
-  #     def persisted?
-  #       false
-  #     end
-  #   end
-  #
-  #   cm = ContactMessage.new
-  #   cm.to_model == self #=> true
-  #   cm.to_key           #=> nil
-  #   cm.to_param         #=> nil
-  #
+  # Include ActiveModel::Conversion if your object "acts like an ActiveModel model".
   module Conversion
-    # If your object is already designed to implement all of the Active Model you can use
-    # the default to_model implementation, which simply returns self.
-    # 
-    # If your model does not act like an Active Model object, then you should define
-    # <tt>:to_model</tt> yourself returning a proxy object that wraps your object
-    # with Active Model compliant methods.
     def to_model
       self
     end
-
-    # Returns an Enumerable of all (primary) key attributes or nil if persisted? is fakse
-    def to_key
-      persisted? ? [id] : nil
-    end
-
-    # Returns a string representing the object's key suitable for use in URLs,
-    # or nil if persisted? is false
-    def to_param
-      to_key ? to_key.join('-') : nil
-    end
   end
 end

data/lib/active_model/dirty.rb

@@ -1,48 +1,5 @@
-require 'active_model/attribute_methods'
-require 'active_support/concern'
-require 'active_support/hash_with_indifferent_access'
-require 'active_support/core_ext/object/duplicable'
-
 module ActiveModel
-  # <tt>ActiveModel::Dirty</tt> provides a way to track changes in your
-  # object in the same way as ActiveRecord does.
-  # 
-  # The requirements to implement ActiveModel::Dirty are:
-  #
-  # * <tt>include ActiveModel::Dirty</tt> in your object
-  # * Call <tt>define_attribute_methods</tt> passing each method you want to track
-  # * Call <tt>attr_name_will_change!</tt> before each change to the tracked attribute
-  # 
-  # If you wish to also track previous changes on save or update, you need to add
-  # 
-  #   @previously_changed = changes
-  # 
-  # inside of your save or update method.
-  # 
-  # A minimal implementation could be:
-  # 
-  #   class Person
-  #   
-  #     include ActiveModel::Dirty
-  #   
-  #     define_attribute_methods [:name]
-  #   
-  #     def name
-  #       @name
-  #     end
-  #   
-  #     def name=(val)
-  #       name_will_change!
-  #       @name = val
-  #     end
-  #   
-  #     def save
-  #       @previously_changed = changes
-  #     end
-  #   
-  #   end
-  # 
-  # == Examples:
+  # Track unsaved attribute changes.
   #
   # A newly instantiated object is unchanged:
   #   person = Person.find_by_name('Uncle Bob')
@@ -112,7 +69,7 @@ module ActiveModel
     #   person.name = 'bob'
     #   person.changes # => { 'name' => ['bill', 'bob'] }
     def changes
-      changed.inject(HashWithIndifferentAccess.new){ |h, attr| h[attr] = attribute_change(attr); h }
+      changed.inject({}) { |h, attr| h[attr] = attribute_change(attr); h }
     end
 
     # Map of attributes that were changed when the model was saved.
@@ -121,15 +78,19 @@ module ActiveModel
     #   person.save
     #   person.previous_changes # => {'name' => ['bob, 'robert']}
     def previous_changes
-      @previously_changed
-    end
-
-    # Map of change <tt>attr => original value</tt>.
-    def changed_attributes
-      @changed_attributes ||= {}
+      previously_changed_attributes
     end
 
     private
+      # Map of change <tt>attr => original value</tt>.
+      def changed_attributes
+        @changed_attributes ||= {}
+      end
+
+      # Map of fields that were changed when the model was saved
+      def previously_changed_attributes
+        @previously_changed || {}
+      end
 
       # Handle <tt>*_changed?</tt> for +method_missing+.
       def attribute_changed?(attr)

data/lib/active_model/errors.rb

@@ -1,71 +1,10 @@
-# -*- coding: utf-8 -*-
-
-require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/object/blank'
 require 'active_support/ordered_hash'
 
 module ActiveModel
-  # Provides a modified +OrderedHash+ that you can include in your object
-  # for handling error messages and interacting with Action Pack helpers.
-  # 
-  # A minimal implementation could be:
-  # 
-  #   class Person
-  #   
-  #     # Required dependency for ActiveModel::Errors
-  #     extend ActiveModel::Naming
-  # 
-  #     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
-  #   
-  #     # The following methods are needed to be minimally implemented
-  #
-  #     def read_attribute_for_validation(attr)
-  #       send(attr)
-  #     end
-  #   
-  #     def ErrorsPerson.human_attribute_name(attr, options = {})
-  #       attr
-  #     end
-  #   
-  #     def ErrorsPerson.lookup_ancestors
-  #       [self]
-  #     end
-  #   
-  #   end
-  # 
-  # The last three methods are required in your object for Errors to be
-  # able to generate error messages correctly and also handle multiple
-  # languages.  Of course, if you extend your object with ActiveModel::Translations
-  # you will not need to implement the last two.  Likewise, using
-  # ActiveModel::Validations will handle the validation related methods
-  # for you.
-  # 
-  # The above allows you to do:
-  # 
-  #   p = Person.new
-  #   p.validate!             # => ["can not be nil"]
-  #   p.errors.full_messages  # => ["name can not be nil"]
-  #   # etc..
   class Errors < ActiveSupport::OrderedHash
     include DeprecatedErrorMethods
 
-    # Pass in the instance of the object that is using the errors object.
-    # 
-    #   class Person
-    #     def initialize
-    #       @errors = ActiveModel::Errors.new(self)
-    #     end
-    #   end
     def initialize(base)
       @base = base
       super()
@@ -74,10 +13,6 @@ module ActiveModel
     alias_method :get, :[]
     alias_method :set, :[]=
 
-    # When passed a symbol or a name of a method, returns an array of errors for the method.
-    # 
-    #   p.errors[:name]   #=> ["can not be nil"]
-    #   p.errors['name']  #=> ["can not be nil"]
     def [](attribute)
       if errors = get(attribute.to_sym)
         errors
@@ -86,78 +21,28 @@ module ActiveModel
       end
     end
 
-    # Adds to the supplied attribute the supplied error message.
-    # 
-    #   p.errors[:name] = "must be set"
-    #   p.errors[:name] #=> ['must be set']
     def []=(attribute, error)
       self[attribute.to_sym] << error
     end
 
-    # Iterates through each error key, value pair in the error messages hash.
-    # Yields the attribute and the error for that attribute.  If the attribute
-    # has more than one error message, yields once for each error message.
-    # 
-    #   p.errors.add(:name, "can't be blank")
-    #   p.errors.each do |attribute, errors_array|
-    #     # Will yield :name and "can't be blank"
-    #   end
-    # 
-    #   p.errors.add(:name, "must be specified")
-    #   p.errors.each do |attribute, errors_array|
-    #     # Will yield :name and "can't be blank"
-    #     # then yield :name and "must be specified"
-    #   end
     def each
       each_key do |attribute|
         self[attribute].each { |error| yield attribute, error }
       end
     end
 
-    # Returns the number of error messages.
-    # 
-    #   p.errors.add(:name, "can't be blank")
-    #   p.errors.size #=> 1
-    #   p.errors.add(:name, "must be specified")
-    #   p.errors.size #=> 2
     def size
       values.flatten.size
     end
 
-    # Returns an array of error messages, with the attribute name included
-    # 
-    #   p.errors.add(:name, "can't be blank")
-    #   p.errors.add(:name, "must be specified")
-    #   p.errors.to_a   #=>   ["name can't be blank", "name must be specified"]
     def to_a
       full_messages
     end
 
-    # Returns the number of error messages.
-    #   p.errors.add(:name, "can't be blank")
-    #   p.errors.count #=> 1
-    #   p.errors.add(:name, "must be specified")
-    #   p.errors.count #=> 2
     def count
       to_a.size
     end
 
-    # Returns true if there are any errors, false if not.
-    def empty?
-      all? { |k, v| v && v.empty? }
-    end
-
-    # Returns an xml formatted representation of the Errors hash.
-    # 
-    #   p.errors.add(:name, "can't be blank")
-    #   p.errors.add(:name, "must be specified")
-    #   p.errors.to_xml   #=> Produces:
-    # 
-    #   #  <?xml version=\"1.0\" encoding=\"UTF-8\"?>
-    #   #  <errors>
-    #   #    <error>name can't be blank</error>
-    #   #    <error>name must be specified</error>
-    #   #  </errors>
     def to_xml(options={})
       require 'builder' unless defined? ::Builder
       options[:root]    ||= "errors"
@@ -170,17 +55,14 @@ module ActiveModel
       end
     end
 
-    # Adds +message+ to the error messages on +attribute+, which will be returned on a call to
-    # <tt>on(attribute)</tt> for the same attribute. More than one error can be added to the same
-    # +attribute+ in which case an array will be returned on a call to <tt>on(attribute)</tt>.
-    # If no +message+ is supplied, <tt>:invalid</tt> is assumed.
-    # 
-    # If +message+ is a symbol, it will be translated using the appropriate scope (see +translate_error+).
-    # If +message+ is a proc, it will be called, allowing for things like <tt>Time.now</tt> to be used within an error.
+    # Adds an error message (+messsage+) to the +attribute+, which will be returned on a call to <tt>on(attribute)</tt>
+    # for the same attribute and ensure that this error object returns false when asked if <tt>empty?</tt>. More than one
+    # error can be added to the same +attribute+ in which case an array will be returned on a call to <tt>on(attribute)</tt>.
+    # If no +messsage+ is supplied, :invalid is assumed.
+    # If +message+ is a Symbol, it will be translated, using the appropriate scope (see translate_error).
     def add(attribute, message = nil, options = {})
       message ||= :invalid
       message = generate_message(attribute, message, options) if message.is_a?(Symbol)
-      message = message.call if message.is_a?(Proc)
       self[attribute] << message
     end
 
@@ -211,7 +93,7 @@ module ActiveModel
     #   company = Company.create(:address => '123 First St.')
     #   company.errors.full_messages # =>
     #     ["Name is too short (minimum is 5 characters)", "Name can't be blank", "Address can't be blank"]
-    def full_messages
+    def full_messages(options = {})
       full_messages = []
 
       each do |attribute, messages|
@@ -221,12 +103,10 @@ module ActiveModel
         if attribute == :base
           messages.each {|m| full_messages << m }
         else
-          attr_name = attribute.to_s.gsub('.', '_').humanize
-          attr_name = @base.class.human_attribute_name(attribute, :default => attr_name)
-          options = { :default => "%{attribute} %{message}", :attribute => attr_name }
-
+          attr_name = attribute.to_s.humanize
+          prefix = attr_name + I18n.t('activemodel.errors.format.separator', :default => ' ')
           messages.each do |m|
-            full_messages << I18n.t(:"errors.format", options.merge(:message => m))
+            full_messages <<  "#{prefix}#{m}"
           end
         end
       end
@@ -249,35 +129,31 @@ module ActiveModel
     # <li><tt>activemodel.errors.models.admin.blank</tt></li>
     # <li><tt>activemodel.errors.models.user.attributes.title.blank</tt></li>
     # <li><tt>activemodel.errors.models.user.blank</tt></li>
-    # <li>any default you provided through the +options+ hash (in the activemodel.errors scope)</li>
     # <li><tt>activemodel.errors.messages.blank</tt></li>
-    # <li><tt>errors.attributes.title.blank</tt></li>
-    # <li><tt>errors.messages.blank</tt></li>
+    # <li>any default you provided through the +options+ hash (in the activemodel.errors scope)</li>
     # </ol>
     def generate_message(attribute, message = :invalid, options = {})
       message, options[:default] = options[:default], message if options[:default].is_a?(Symbol)
 
-      defaults = @base.class.lookup_ancestors.map do |klass|
-        [ :"#{@base.class.i18n_scope}.errors.models.#{klass.model_name.underscore}.attributes.#{attribute}.#{message}",
-          :"#{@base.class.i18n_scope}.errors.models.#{klass.model_name.underscore}.#{message}" ]
+      klass_ancestors = [@base.class]
+      klass_ancestors += @base.class.ancestors.reject {|x| x.is_a?(Module)}
+
+      defaults = klass_ancestors.map do |klass|
+        [ :"models.#{klass.name.underscore}.attributes.#{attribute}.#{message}",
+          :"models.#{klass.name.underscore}.#{message}" ]
       end
 
       defaults << options.delete(:default)
-      defaults << :"#{@base.class.i18n_scope}.errors.messages.#{message}"
-      defaults << :"errors.attributes.#{attribute}.#{message}"
-      defaults << :"errors.messages.#{message}"
-
-      defaults.compact!
-      defaults.flatten!
+      defaults = defaults.compact.flatten << :"messages.#{message}"
 
       key = defaults.shift
       value = @base.send(:read_attribute_for_validation, attribute)
 
-      options = {
-        :default => defaults,
-        :model => @base.class.model_name.human,
-        :attribute => @base.class.human_attribute_name(attribute),
-        :value => value
+      options = { :default => defaults,
+        :model => @base.class.name.humanize,
+        :attribute => attribute.to_s.humanize,
+        :value => value,
+        :scope => [:activemodel, :errors]
       }.merge(options)
 
       I18n.translate(key, options)

data/lib/active_model/lint.rb

@@ -13,34 +13,8 @@
 module ActiveModel
   module Lint
     module Tests
-
-      # == Responds to <tt>to_key</tt>
-      #
-      # Returns an Enumerable of all (primary) key attributes
-      # or nil if model.persisted? is false
-      def test_to_key
-        assert model.respond_to?(:to_key), "The model should respond to to_key"
-        def model.persisted?() false end
-        assert model.to_key.nil?
-      end
-
-      # == Responds to <tt>to_param</tt>
-      #
-      # Returns a string representing the object's key suitable for use in URLs
-      # or nil if model.persisted? is false.
-      #
-      # Implementers can decide to either raise an exception or provide a default
-      # in case the record uses a composite primary key. There are no tests for this
-      # behavior in lint because it doesn't make sense to force any of the possible
-      # implementation strategies on the implementer. However, if the resource is
-      # not persisted?, then to_param should always return nil.
-      def test_to_param
-        assert model.respond_to?(:to_param), "The model should respond to to_param"
-        def model.persisted?() false end
-        assert model.to_param.nil?
-      end
-
-      # == Responds to <tt>valid?</tt>
+      # valid?
+      # ------
       #
       # Returns a boolean that specifies whether the object is in a valid or invalid
       # state.
@@ -49,38 +23,30 @@ module ActiveModel
         assert_boolean model.valid?, "valid?"
       end
 
-      # == Responds to <tt>persisted?</tt>
+      # new_record?
+      # -----------
       #
       # Returns a boolean that specifies whether the object has been persisted yet.
       # This is used when calculating the URL for an object. If the object is
       # not persisted, a form for that object, for instance, will be POSTed to the
       # collection. If it is persisted, a form for the object will put PUTed to the
       # URL for the object.
-      def test_persisted?
-        assert model.respond_to?(:persisted?), "The model should respond to persisted?"
-        assert_boolean model.persisted?, "persisted?"
+      def test_new_record?
+        assert model.respond_to?(:new_record?), "The model should respond to new_record?"
+        assert_boolean model.new_record?, "new_record?"
       end
 
-      # == Naming
-      #
-      # Model.model_name must returns a string with some convenience methods as
-      # :human and :partial_path. Check ActiveModel::Naming for more information.
-      #
-      def test_model_naming
-        assert model.class.respond_to?(:model_name), "The model should respond to model_name"
-        model_name = model.class.model_name
-        assert_kind_of String, model_name
-        assert_kind_of String, model_name.human
-        assert_kind_of String, model_name.partial_path
-        assert_kind_of String, model_name.singular
-        assert_kind_of String, model_name.plural
+      def test_destroyed?
+        assert model.respond_to?(:destroyed?), "The model should respond to destroyed?"
+        assert_boolean model.destroyed?, "destroyed?"
       end
 
-      # == Errors Testing
-      # 
+      # errors
+      # ------
+      #
       # Returns an object that has :[] and :full_messages defined on it. See below
       # for more details.
-      #
+
       # Returns an Array of Strings that are the errors for the attribute in
       # question. If localization is used, the Strings should be localized
       # for the current locale. If no error is present, this method should