activemodel 3.0.0.beta4 → 3.0.pre

data/lib/active_model/locale/en.yml

@@ -1,27 +1,24 @@
 en:
-  errors:
-    # The default format use in full error messages.
-    format: "%{attribute} %{message}"
-
-    # The values :model, :attribute and :value are always available for interpolation
-    # The value :count is available when applicable. Can be used for pluralization.
-    messages:
-      inclusion: "is not included in the list"
-      exclusion: "is reserved"
-      invalid: "is invalid"
-      confirmation: "doesn't match confirmation"
-      accepted: "must be accepted"
-      empty: "can't be empty"
-      blank: "can't be blank"
-      too_long: "is too long (maximum is %{count} characters)"
-      too_short: "is too short (minimum is %{count} characters)"
-      wrong_length: "is the wrong length (should be %{count} characters)"
-      not_a_number: "is not a number"
-      not_an_integer: "must be an integer"
-      greater_than: "must be greater than %{count}"
-      greater_than_or_equal_to: "must be greater than or equal to %{count}"
-      equal_to: "must be equal to %{count}"
-      less_than: "must be less than %{count}"
-      less_than_or_equal_to: "must be less than or equal to %{count}"
-      odd: "must be odd"
-      even: "must be even"
+  activemodel:
+    errors:
+      # The values :model, :attribute and :value are always available for interpolation
+      # The value :count is available when applicable. Can be used for pluralization.
+      messages:
+        inclusion: "is not included in the list"
+        exclusion: "is reserved"
+        invalid: "is invalid"
+        confirmation: "doesn't match confirmation"
+        accepted: "must be accepted"
+        empty: "can't be empty"
+        blank: "can't be blank"
+        too_long: "is too long (maximum is {{count}} characters)"
+        too_short: "is too short (minimum is {{count}} characters)"
+        wrong_length: "is the wrong length (should be {{count}} characters)"
+        not_a_number: "is not a number"
+        greater_than: "must be greater than {{count}}"
+        greater_than_or_equal_to: "must be greater than or equal to {{count}}"
+        equal_to: "must be equal to {{count}}"
+        less_than: "must be less than {{count}}"
+        less_than_or_equal_to: "must be less than or equal to {{count}}"
+        odd: "must be odd"
+        even: "must be even"

data/lib/active_model/naming.rb

@@ -1,62 +1,26 @@
 require 'active_support/inflector'
 
 module ActiveModel
-
   class Name < String
-    attr_reader :singular, :plural, :element, :collection, :partial_path
+    attr_reader :singular, :plural, :element, :collection, :partial_path, :human
     alias_method :cache_key, :collection
 
-    def initialize(klass)
-      super(klass.name)
-      @klass = klass
+    def initialize(name)
+      super
       @singular = ActiveSupport::Inflector.underscore(self).tr('/', '_').freeze
       @plural = ActiveSupport::Inflector.pluralize(@singular).freeze
       @element = ActiveSupport::Inflector.underscore(ActiveSupport::Inflector.demodulize(self)).freeze
-      @human = ActiveSupport::Inflector.humanize(@element).freeze
+      @human = @element.gsub(/_/, " ")
       @collection = ActiveSupport::Inflector.tableize(self).freeze
       @partial_path = "#{@collection}/#{@element}".freeze
     end
-
-    # Transform the model name into a more humane format, using I18n. By default,
-    # it will underscore then humanize the class name (BlogPost.model_name.human #=> "Blog post").
-    # Specify +options+ with additional translating options.
-    def human(options={})
-      return @human unless @klass.respond_to?(:lookup_ancestors) &&
-                           @klass.respond_to?(:i18n_scope)
-
-      defaults = @klass.lookup_ancestors.map do |klass|
-        klass.model_name.underscore.to_sym
-      end
-
-      defaults << options.delete(:default) if options[:default]
-      defaults << @human
-
-      options.reverse_merge! :scope => [@klass.i18n_scope, :models], :count => 1, :default => defaults
-      I18n.translate(defaults.shift, options)
-    end
   end
 
-  # ActiveModel::Naming is a module that creates a +model_name+ method on your
-  # object.
-  # 
-  # To implement, just extend ActiveModel::Naming in your object:
-  # 
-  #   class BookCover
-  #     extend ActiveModel::Naming
-  #   end
-  # 
-  #   BookCover.model_name        #=> "BookCover"
-  #   BookCover.model_name.human  #=> "Book cover"
-  # 
-  # Providing the functionality that ActiveModel::Naming provides in your object
-  # is required to pass the ActiveModel Lint test.  So either extending the provided
-  # method below, or rolling your own is required..
   module Naming
     # Returns an ActiveModel::Name object for module. It can be
     # used to retrieve all kinds of naming-related information.
     def model_name
-      @_model_name ||= ActiveModel::Name.new(self)
+      @_model_name ||= ActiveModel::Name.new(name)
     end
   end
-  
 end

data/lib/active_model/observing.rb

@@ -1,13 +1,17 @@
+require 'observer'
 require 'singleton'
 require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/module/aliasing'
 require 'active_support/core_ext/string/inflections'
-require 'active_support/core_ext/string/conversions'
 
 module ActiveModel
   module Observing
     extend ActiveSupport::Concern
 
+    included do
+      extend Observable
+    end
+
     module ClassMethods
       # Activates the observers assigned. Examples:
       #
@@ -20,9 +24,8 @@ module ActiveModel
       #   # Same as above, just using explicit class references
       #   ActiveRecord::Base.observers = Cacher, GarbageCollector
       #
-      # Note: Setting this does not instantiate the observers yet. 
-      # +instantiate_observers+ is called during startup, and before
-      # each development request.
+      # Note: Setting this does not instantiate the observers yet. +instantiate_observers+ is
+      # called during startup, and before each development request.
       def observers=(*values)
         @observers = values.flatten
       end
@@ -37,26 +40,6 @@ module ActiveModel
         observers.each { |o| instantiate_observer(o) }
       end
 
-      def add_observer(observer)
-        unless observer.respond_to? :update
-          raise ArgumentError, "observer needs to respond to `update'"
-        end
-        @observer_instances ||= []
-        @observer_instances << observer
-      end
-
-      def notify_observers(*arg)
-        if defined? @observer_instances
-          for observer in @observer_instances
-            observer.update(*arg)
-          end
-        end
-      end
-
-      def count_observers
-        @observer_instances.size
-      end
-
       protected
         def instantiate_observer(observer) #:nodoc:
           # string/symbol
@@ -72,6 +55,7 @@ module ActiveModel
         # Notify observers when the observed class is subclassed.
         def inherited(subclass)
           super
+          changed
           notify_observers :observed_class_inherited, subclass
         end
     end
@@ -85,6 +69,7 @@ module ActiveModel
       #   notify_observers(:after_save)
       # end
       def notify_observers(method)
+        self.class.changed
         self.class.notify_observers(method, self)
       end
   end
@@ -117,12 +102,10 @@ module ActiveModel
   #
   # == Observing a class that can't be inferred
   #
-  # Observers will by default be mapped to the class with which they share a
-  # name. So CommentObserver will be tied to observing Comment, ProductManagerObserver
-  # to ProductManager, and so on. If you want to name your observer differently than 
-  # the class you're interested in observing, you can use the Observer.observe class 
-  # method which takes either the concrete class (Product) or a symbol for that 
-  # class (:product):
+  # Observers will by default be mapped to the class with which they share a name. So CommentObserver will
+  # be tied to observing Comment, ProductManagerObserver to ProductManager, and so on. If you want to name your observer
+  # differently than the class you're interested in observing, you can use the Observer.observe class method which takes
+  # either the concrete class (Product) or a symbol for that class (:product):
   #
   #   class AuditObserver < ActiveModel::Observer
   #     observe :account
@@ -132,8 +115,7 @@ module ActiveModel
   #     end
   #   end
   #
-  # If the audit observer needs to watch more than one kind of object, this can be 
-  # specified with multiple arguments:
+  # If the audit observer needs to watch more than one kind of object, this can be specified with multiple arguments:
   #
   #   class AuditObserver < ActiveModel::Observer
   #     observe :account, :balance
@@ -143,8 +125,7 @@ module ActiveModel
   #     end
   #   end
   #
-  # The AuditObserver will now act on both updates to Account and Balance by treating 
-  # them both as records.
+  # The AuditObserver will now act on both updates to Account and Balance by treating them both as records.
   #
   class Observer
     include Singleton
@@ -163,7 +144,7 @@ module ActiveModel
       #
       #   class AuditObserver < ActiveModel::Observer
       #     def self.observed_classes
-      #       [Account, Balance]
+      #       [AccountObserver, BalanceObserver]
       #     end
       #   end
       def observed_classes

data/lib/active_model/serialization.rb

@@ -2,63 +2,6 @@ require 'active_support/core_ext/hash/except'
 require 'active_support/core_ext/hash/slice'
 
 module ActiveModel
-  # Provides a basic serialization to a serializable_hash for your object.
-  # 
-  # A minimal implementation could be:
-  #   
-  #   class Person
-  #   
-  #     include ActiveModel::Serialization
-  #   
-  #     attr_accessor :name
-  #   
-  #     def attributes
-  #       @attributes ||= {'name' => 'nil'}
-  #     end
-  #   
-  #   end
-  # 
-  # Which would provide you with:
-  # 
-  #   person = Person.new
-  #   person.serializable_hash   # => {"name"=>nil}
-  #   person.name = "Bob"
-  #   person.serializable_hash   # => {"name"=>"Bob"}
-  #
-  # You need to declare some sort of attributes hash which contains the attributes
-  # you want to serialize and their current value.
-  # 
-  # Most of the time though, you will want to include the JSON or XML 
-  # serializations.  Both of these modules automatically include the 
-  # ActiveModel::Serialization module, so there is no need to explicitly
-  # include it.
-  # 
-  # So a minimal implementation including XML and JSON would be:
-  #   
-  #   class Person
-  #   
-  #     include ActiveModel::Serializers::JSON
-  #     include ActiveModel::Serializers::Xml
-  #   
-  #     attr_accessor :name
-  #   
-  #     def attributes
-  #       @attributes ||= {'name' => 'nil'}
-  #     end
-  #   
-  #   end
-  # 
-  # Which would provide you with:
-  # 
-  #   person = Person.new
-  #   person.serializable_hash   # => {"name"=>nil}
-  #   person.to_json             # => "{\"name\":null}"
-  #   person.to_xml              # => "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<serial-person...
-  # 
-  #   person.name = "Bob"
-  #   person.serializable_hash   # => {"name"=>"Bob"}
-  #   person.to_json             # => "{\"name\":\"Bob\"}"
-  #   person.to_xml              # => "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<serial-person...
   module Serialization
     def serializable_hash(options = nil)
       options ||= {}

data/lib/active_model/serializers/json.rb

@@ -1,5 +1,5 @@
 require 'active_support/json'
-require 'active_support/core_ext/class/attribute'
+require 'active_support/core_ext/class/attribute_accessors'
 
 module ActiveModel
   module Serializers
@@ -10,18 +10,19 @@ module ActiveModel
       included do
         extend ActiveModel::Naming
 
-        class_attribute :include_root_in_json
-        self.include_root_in_json = true
+        cattr_accessor :include_root_in_json, :instance_writer => false
       end
 
       # Returns a JSON string representing the model. Some configuration is
       # available through +options+.
       #
-      # The option <tt>ActiveModel::Base.include_root_in_json</tt> controls the
-      # top-level behavior of to_json. It is true by default. When it is <tt>true</tt>,
+      # The option <tt>ActiveRecord::Base.include_root_in_json</tt> controls the
+      # top-level behavior of to_json. In a new Rails application, it is set to 
+      # <tt>true</tt> in initializers/new_rails_defaults.rb. When it is <tt>true</tt>,
       # to_json will emit a single root node named after the object's type. For example:
       #
       #   konata = User.find(1)
+      #   ActiveRecord::Base.include_root_in_json = true
       #   konata.to_json
       #   # => { "user": {"id": 1, "name": "Konata Izumi", "age": 16,
       #                   "created_at": "2006/08/01", "awesome": true} }
@@ -80,11 +81,7 @@ module ActiveModel
       #                    "title": "So I was thinking"}]}
       def encode_json(encoder)
         hash = serializable_hash(encoder.options)
-        if include_root_in_json
-          custom_root = encoder.options && encoder.options[:root]
-          hash = { custom_root || self.class.model_name.element => hash }
-        end
-
+        hash = { self.class.model_name.element => hash } if include_root_in_json
         ActiveSupport::JSON.encode(hash)
       end
 
@@ -93,9 +90,7 @@ module ActiveModel
       end
 
       def from_json(json)
-        hash = ActiveSupport::JSON.decode(json)
-        hash = hash.values.first if include_root_in_json
-        self.attributes = hash
+        self.attributes = ActiveSupport::JSON.decode(json)
         self
       end
     end

data/lib/active_model/serializers/xml.rb

@@ -1,8 +1,5 @@
-require 'active_support/core_ext/array/wrap'
 require 'active_support/core_ext/class/attribute_accessors'
-require 'active_support/core_ext/array/conversions'
 require 'active_support/core_ext/hash/conversions'
-require 'active_support/core_ext/hash/slice'
 
 module ActiveModel
   module Serializers
@@ -14,31 +11,68 @@ module ActiveModel
         class Attribute #:nodoc:
           attr_reader :name, :value, :type
 
-          def initialize(name, serializable, raw_value=nil)
+          def initialize(name, serializable)
             @name, @serializable = name, serializable
-            @value = value || @serializable.send(name)
             @type  = compute_type
+            @value = compute_value
           end
 
-          def decorations
+          # There is a significant speed improvement if the value
+          # does not need to be escaped, as <tt>tag!</tt> escapes all values
+          # to ensure that valid XML is generated. For known binary
+          # values, it is at least an order of magnitude faster to
+          # Base64 encode binary values and directly put them in the
+          # output XML than to pass the original value or the Base64
+          # encoded value to the <tt>tag!</tt> method. It definitely makes
+          # no sense to Base64 encode the value and then give it to
+          # <tt>tag!</tt>, since that just adds additional overhead.
+          def needs_encoding?
+            ![ :binary, :date, :datetime, :boolean, :float, :integer ].include?(type)
+          end
+
+          def decorations(include_types = true)
             decorations = {}
-            decorations[:encoding] = 'base64' if type == :binary
-            decorations[:type] = type unless type == :string
-            decorations[:nil] = true if value.nil?
+
+            if type == :binary
+              decorations[:encoding] = 'base64'
+            end
+
+            if include_types && type != :string
+              decorations[:type] = type
+            end
+
+            if value.nil?
+              decorations[:nil] = true
+            end
+
             decorations
           end
 
-        protected
+          protected
+            def compute_type
+              value = @serializable.send(name)
+              type = Hash::XML_TYPE_NAMES[value.class.name]
+              type ||= :string if value.respond_to?(:to_str)
+              type ||= :yaml
+              type
+            end
 
-          def compute_type
-            type = ActiveSupport::XmlMini::TYPE_NAMES[value.class.name]
-            type ||= :string if value.respond_to?(:to_str)
-            type ||= :yaml
-            type
-          end
+            def compute_value
+              value = @serializable.send(name)
+
+              if formatter = Hash::XML_FORMATTING[type.to_s]
+                value ? formatter.call(value) : nil
+              else
+                value
+              end
+            end
         end
 
         class MethodAttribute < Attribute #:nodoc:
+          protected
+            def compute_type
+              Hash::XML_TYPE_NAMES[@serializable.send(name).class.name] || :string
+            end
         end
 
         attr_reader :options
@@ -51,84 +85,110 @@ module ActiveModel
           @options[:except] = Array.wrap(@options[:except]).map { |n| n.to_s }
         end
 
-        # To replicate the behavior in ActiveRecord#attributes, <tt>:except</tt> 
-        # takes precedence over <tt>:only</tt>.  If <tt>:only</tt> is not set
+        # To replicate the behavior in ActiveRecord#attributes,
+        # <tt>:except</tt> takes precedence over <tt>:only</tt>.  If <tt>:only</tt> is not set
         # for a N level model but is set for the N+1 level models,
         # then because <tt>:except</tt> is set to a default value, the second
         # level model can have both <tt>:except</tt> and <tt>:only</tt> set.  So if
         # <tt>:only</tt> is set, always delete <tt>:except</tt>.
-        def attributes_hash
-          attributes = @serializable.attributes
+        def serializable_attribute_names
+          attribute_names = @serializable.attributes.keys.sort
+
           if options[:only].any?
-            attributes.slice(*options[:only])
+            attribute_names &= options[:only]
           elsif options[:except].any?
-            attributes.except(*options[:except])
-          else
-            attributes
+            attribute_names -= options[:except]
           end
+
+          attribute_names
         end
 
         def serializable_attributes
-          attributes_hash.map do |name, value|
-            self.class::Attribute.new(name, @serializable, value)
-          end
+          serializable_attribute_names.collect { |name| Attribute.new(name, @serializable) }
         end
 
-        def serializable_methods
-          Array.wrap(options[:methods]).inject([]) do |methods, name|
-            methods << self.class::MethodAttribute.new(name.to_s, @serializable) if @serializable.respond_to?(name.to_s)
+        def serializable_method_attributes
+          Array(options[:methods]).inject([]) do |methods, name|
+            methods << MethodAttribute.new(name.to_s, @serializable) if @serializable.respond_to?(name.to_s)
             methods
           end
         end
 
         def serialize
-          require 'builder' unless defined? ::Builder
-
-          options[:indent]  ||= 2
-          options[:builder] ||= ::Builder::XmlMarkup.new(:indent => options[:indent])
-
-          @builder = options[:builder]
-          @builder.instruct! unless options[:skip_instruct]
+          args = [root]
 
-          root = (options[:root] || @serializable.class.model_name.element).to_s
-          root = ActiveSupport::XmlMini.rename_key(root, options)
+          if options[:namespace]
+            args << {:xmlns => options[:namespace]}
+          end
 
-          args = [root]
-          args << {:xmlns => options[:namespace]} if options[:namespace]
-          args << {:type => options[:type]} if options[:type] && !options[:skip_types]
+          if options[:type]
+            args << {:type => options[:type]}
+          end
 
-          @builder.tag!(*args) do
-            add_attributes_and_methods
-            add_extra_behavior
+          builder.tag!(*args) do
+            add_attributes
+            procs = options.delete(:procs)
+            options[:procs] = procs
             add_procs
-            yield @builder if block_given?
+            yield builder if block_given?
           end
         end
 
-      private
+        private
+          def builder
+            @builder ||= begin
+              require 'builder' unless defined? ::Builder
+              options[:indent] ||= 2
+              builder = options[:builder] ||= ::Builder::XmlMarkup.new(:indent => options[:indent])
 
-        def add_extra_behavior
-        end
+              unless options[:skip_instruct]
+                builder.instruct!
+                options[:skip_instruct] = true
+              end
 
-        def add_attributes_and_methods
-          (serializable_attributes + serializable_methods).each do |attribute|
-            key = ActiveSupport::XmlMini.rename_key(attribute.name, options)
-            ActiveSupport::XmlMini.to_tag(key, attribute.value,
-              options.merge(attribute.decorations))
+              builder
+            end
           end
-        end
 
-        def add_procs
-          if procs = options.delete(:procs)
-            Array.wrap(procs).each do |proc|
-              if proc.arity == 1
-                proc.call(options)
-              else
-                proc.call(options, @serializable)
+          def root
+            root = (options[:root] || @serializable.class.model_name.singular).to_s
+            reformat_name(root)
+          end
+
+          def dasherize?
+            !options.has_key?(:dasherize) || options[:dasherize]
+          end
+
+          def camelize?
+            options.has_key?(:camelize) && options[:camelize]
+          end
+
+          def reformat_name(name)
+            name = name.camelize if camelize?
+            dasherize? ? name.dasherize : name
+          end
+
+          def add_attributes
+            (serializable_attributes + serializable_method_attributes).each do |attribute|
+              builder.tag!(
+                reformat_name(attribute.name),
+                attribute.value.to_s,
+                attribute.decorations(!options[:skip_types])
+              )
+            end
+          end
+
+          def add_procs
+            if procs = options.delete(:procs)
+              [ *procs ].each do |proc|
+                if proc.arity > 1
+                  proc.call(options, @serializable)
+                else
+                  proc.call(options)
+                end
               end
             end
           end
-        end
       end
 
       def to_xml(options = {}, &block)