Merge commit 'rails/master'

activemodel/lib/active_model.rb

@@ -34,6 +34,7 @@ module ActiveModel
   autoload :Naming, 'active_model/naming'
   autoload :Observer, 'active_model/observing'
   autoload :Observing, 'active_model/observing'
+  autoload :Serializer, 'active_model/serializer'
   autoload :StateMachine, 'active_model/state_machine'
   autoload :TestCase, 'active_model/test_case'
   autoload :Validations, 'active_model/validations'
@@ -41,6 +42,7 @@ module ActiveModel
 
   module Serializers
     autoload :JSON, 'active_model/serializers/json'
+    autoload :Xml, 'active_model/serializers/xml'
   end
 end
 

activemodel/lib/active_model/attributes.rb

@@ -2,6 +2,14 @@
 
 module ActiveModel
   module Attributes
+    def self.append_features(base)
+      unless base.instance_methods.include?('attributes')
+        super
+      else
+        false
+      end
+    end
+
     def attributes
       instance_values
     end

activemodel/lib/active_model/serializer.rb

+require 'active_support/core_ext/hash/except'
+require 'active_support/core_ext/hash/slice'
+
+module ActiveModel
+  class Serializer
+    attr_reader :options
+
+    def initialize(serializable, options = nil)
+      @serializable = serializable
+      @options = options ? options.dup : {}
+
+      @options[:only] = Array.wrap(@options[:only]).map { |n| n.to_s }
+      @options[:except] = Array.wrap(@options[:except]).map { |n| n.to_s }
+    end
+
+    def serialize
+      raise NotImplemented
+    end
+
+    def to_s(&block)
+      serialize(&block)
+    end
+
+    # 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 serializable_attribute_names
+      attribute_names = @serializable.attributes.keys.sort
+
+      if options[:only].any?
+        attribute_names &= options[:only]
+      elsif options[:except].any?
+        attribute_names -= options[:except]
+      end
+
+      attribute_names
+    end
+
+    def serializable_method_names
+      Array.wrap(options[:methods]).inject([]) do |methods, name|
+        methods << name if @serializable.respond_to?(name.to_s)
+        methods
+      end
+    end
+
+    def serializable_names
+      serializable_attribute_names + serializable_method_names
+    end
+
+    def serializable_hash
+      serializable_names.inject({}) { |hash, name|
+        hash[name] = @serializable.send(name)
+        hash
+      }
+    end
+  end
+end

activemodel/lib/active_model/serializers/json.rb

 require 'active_support/json'
 require 'active_support/core_ext/class/attribute_accessors'
-require 'active_support/core_ext/hash/except'
-require 'active_support/core_ext/hash/slice'
 
 module ActiveModel
   module Serializers
@@ -10,29 +8,102 @@ module JSON
       include ActiveModel::Attributes
 
       included do
+        extend ActiveModel::Naming
+
         cattr_accessor :include_root_in_json, :instance_writer => false
       end
 
-      def encode_json(encoder)
-        options = encoder.options || {}
-
-        hash = if options[:only]
-          only = Array.wrap(options[:only]).map { |attr| attr.to_s }
-          attributes.slice(*only)
-        elsif options[:except]
-          except = Array.wrap(options[:except]).map { |attr| attr.to_s }
-          attributes.except(*except)
-        else
-          attributes
+      class Serializer < ActiveModel::Serializer
+        def serializable_hash
+          model = super
+          @serializable.include_root_in_json ?
+            { @serializable.class.model_name.element => model } :
+            model
         end
 
-        hash = { self.class.model_name.element => hash } if include_root_in_json
-        ActiveSupport::JSON.encode(hash)
+        def serialize
+          ActiveSupport::JSON.encode(serializable_hash)
+        end
+      end
+
+      # Returns a JSON string representing the model. Some configuration is
+      # available through +options+.
+      #
+      # 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} }
+      #
+      #   ActiveRecord::Base.include_root_in_json = false
+      #   konata.to_json
+      #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
+      #         "created_at": "2006/08/01", "awesome": true}
+      #
+      # The remainder of the examples in this section assume include_root_in_json is set to
+      # <tt>false</tt>.
+      #
+      # Without any +options+, the returned JSON string will include all
+      # the model's attributes. For example:
+      #
+      #   konata = User.find(1)
+      #   konata.to_json
+      #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
+      #         "created_at": "2006/08/01", "awesome": true}
+      #
+      # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit the attributes
+      # included, and work similar to the +attributes+ method. For example:
+      #
+      #   konata.to_json(:only => [ :id, :name ])
+      #   # => {"id": 1, "name": "Konata Izumi"}
+      #
+      #   konata.to_json(:except => [ :id, :created_at, :age ])
+      #   # => {"name": "Konata Izumi", "awesome": true}
+      #
+      # To include any methods on the model, use <tt>:methods</tt>.
+      #
+      #   konata.to_json(:methods => :permalink)
+      #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
+      #         "created_at": "2006/08/01", "awesome": true,
+      #         "permalink": "1-konata-izumi"}
+      #
+      # To include associations, use <tt>:include</tt>.
+      #
+      #   konata.to_json(:include => :posts)
+      #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
+      #         "created_at": "2006/08/01", "awesome": true,
+      #         "posts": [{"id": 1, "author_id": 1, "title": "Welcome to the weblog"},
+      #                   {"id": 2, author_id: 1, "title": "So I was thinking"}]}
+      #
+      # 2nd level and higher order associations work as well:
+      #
+      #   konata.to_json(:include => { :posts => {
+      #                                  :include => { :comments => {
+      #                                                :only => :body } },
+      #                                  :only => :title } })
+      #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
+      #         "created_at": "2006/08/01", "awesome": true,
+      #         "posts": [{"comments": [{"body": "1st post!"}, {"body": "Second!"}],
+      #                    "title": "Welcome to the weblog"},
+      #                   {"comments": [{"body": "Don't think too hard"}],
+      #                    "title": "So I was thinking"}]}
+      def encode_json(encoder)
+        Serializer.new(self, encoder.options).to_s
       end
 
       def as_json(options = nil)
         self
       end
+
+      def from_json(json)
+        self.attributes = ActiveSupport::JSON.decode(json)
+        self
+      end
     end
   end
 end

activemodel/lib/active_model/serializers/xml.rb

+require 'active_support/core_ext/class/attribute_accessors'
+require 'active_support/core_ext/hash/conversions'
+
+module ActiveModel
+  module Serializers
+    module Xml
+      extend ActiveSupport::Concern
+      include ActiveModel::Attributes
+
+      class Serializer < ActiveModel::Serializer #:nodoc:
+        class Attribute #:nodoc:
+          attr_reader :name, :value, :type
+
+          def initialize(name, serializable)
+            @name, @serializable = name, serializable
+            @type  = compute_type
+            @value = compute_value
+          end
+
+          def needs_encoding?
+            ![ :binary, :date, :datetime, :boolean, :float, :integer ].include?(type)
+          end
+
+          def decorations(include_types = true)
+            decorations = {}
+
+            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
+            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_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
+
+        def builder
+          @builder ||= begin
+            require 'builder' unless defined? ::Builder
+            options[:indent] ||= 2
+            builder = options[:builder] ||= ::Builder::XmlMarkup.new(:indent => options[:indent])
+
+            unless options[:skip_instruct]
+              builder.instruct!
+              options[:skip_instruct] = true
+            end
+
+            builder
+          end
+        end
+
+        def root
+          root = (options[:root] || @serializable.class.to_s.underscore).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 serializable_attributes
+          serializable_attribute_names.collect { |name| Attribute.new(name, @serializable) }
+        end
+
+        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 add_attributes
+          (serializable_attributes + serializable_method_attributes).each do |attribute|
+            add_tag(attribute)
+          end
+        end
+
+        def add_procs
+          if procs = options.delete(:procs)
+            [ *procs ].each do |proc|
+              proc.call(options)
+            end
+          end
+        end
+
+        def add_tag(attribute)
+          builder.tag!(
+            reformat_name(attribute.name),
+            attribute.value.to_s,
+            attribute.decorations(!options[:skip_types])
+          )
+        end
+
+        def serialize
+          args = [root]
+
+          if options[:namespace]
+            args << {:xmlns => options[:namespace]}
+          end
+
+          if options[:type]
+            args << {:type => options[:type]}
+          end
+
+          builder.tag!(*args) do
+            add_attributes
+            procs = options.delete(:procs)
+            options[:procs] = procs
+            add_procs
+            yield builder if block_given?
+          end
+        end
+
+        private
+          def reformat_name(name)
+            name = name.camelize if camelize?
+            dasherize? ? name.dasherize : name
+          end
+      end
+
+      def to_xml(options = {}, &block)
+        serializer = Serializer.new(self, options)
+        block_given? ? serializer.to_s(&block) : serializer.to_s
+      end
+
+      def from_xml(xml)
+        self.attributes = Hash.from_xml(xml).values.first
+        self
+      end
+    end
+  end
+end

activemodel/test/cases/json_serialization_test.rb → activemodel/test/cases/serializeration/json_serialization_test.rb

 require 'cases/helper'
+require 'models/contact'
 
-class JsonSerializationTest < ActiveModel::TestCase
-  class Contact
-    extend ActiveModel::Naming
-    include ActiveModel::Serializers::JSON
-    attr_accessor :name, :age, :created_at, :awesome, :preferences
-  end
+class Contact
+  include ActiveModel::Serializers::JSON
+end
 
+class JsonSerializationTest < ActiveModel::TestCase
   def setup
     @contact = Contact.new
     @contact.name = 'Konata Izumi'
@@ -61,4 +60,18 @@ def setup
     assert json.include?(%("created_at":#{ActiveSupport::JSON.encode(Time.utc(2006, 8, 1))}))
     assert_match %r{"preferences":\{"shows":"anime"\}}, json
   end
+
+  test "methds are called on object" do
+    # Define methods on fixture.
+    def @contact.label; "Has cheezburger"; end
+    def @contact.favorite_quote; "Constraints are liberating"; end
+
+    # Single method.
+    assert_match %r{"label":"Has cheezburger"}, @contact.to_json(:only => :name, :methods => :label)
+
+    # Both methods.
+    methods_json = @contact.to_json(:only => :name, :methods => [:label, :favorite_quote])
+    assert_match %r{"label":"Has cheezburger"}, methods_json
+    assert_match %r{"favorite_quote":"Constraints are liberating"}, methods_json
+  end
 end

activemodel/test/cases/serializeration/xml_serialization_test.rb

+require 'cases/helper'
+require 'models/contact'
+
+class Contact
+  include ActiveModel::Serializers::Xml
+end
+
+class XmlSerializationTest < ActiveModel::TestCase
+  def setup
+    @contact = Contact.new
+    @contact.name = 'aaron stack'
+    @contact.age = 25
+    @contact.created_at = Time.utc(2006, 8, 1)
+    @contact.awesome = false
+    @contact.preferences = { :gem => 'ruby' }
+  end
+
+  test "should serialize default root" do
+    @xml = @contact.to_xml
+    assert_match %r{^<contact>},  @xml
+    assert_match %r{</contact>$}, @xml
+  end
+
+  test "should serialize default root with namespace" do
+    @xml = @contact.to_xml :namespace => "http://xml.rubyonrails.org/contact"
+    assert_match %r{^<contact xmlns="http://xml.rubyonrails.org/contact">}, @xml
+    assert_match %r{</contact>$}, @xml
+  end
+
+  test "should serialize custom root" do
+    @xml = @contact.to_xml :root => 'xml_contact'
+    assert_match %r{^<xml-contact>},  @xml
+    assert_match %r{</xml-contact>$}, @xml
+  end
+
+  test "should allow undasherized tags" do
+    @xml = @contact.to_xml :root => 'xml_contact', :dasherize => false
+    assert_match %r{^<xml_contact>},  @xml
+    assert_match %r{</xml_contact>$}, @xml
+    assert_match %r{<created_at},     @xml
+  end
+
+  test "should allow camelized tags" do
+    @xml = @contact.to_xml :root => 'xml_contact', :camelize => true
+    assert_match %r{^<XmlContact>},  @xml
+    assert_match %r{</XmlContact>$}, @xml
+    assert_match %r{<CreatedAt},     @xml
+  end
+
+  test "should allow skipped types" do
+    @xml = @contact.to_xml :skip_types => true
+    assert %r{<age>25</age>}.match(@xml)
+  end
+
+  test "should include yielded additions" do
+    @xml = @contact.to_xml do |xml|
+      xml.creator "David"
+    end
+    assert_match %r{<creator>David</creator>}, @xml
+  end
+
+  test "should serialize string" do
+    assert_match %r{<name>aaron stack</name>}, @contact.to_xml
+  end
+
+  test "should serialize integer" do
+    assert_match %r{<age type="integer">25</age>}, @contact.to_xml
+  end
+
+  test "should serialize datetime" do
+    assert_match %r{<created-at type=\"datetime\">2006-08-01T00:00:00Z</created-at>}, @contact.to_xml
+  end
+
+  test "should serialize boolean" do
+    assert_match %r{<awesome type=\"boolean\">false</awesome>}, @contact.to_xml
+  end
+
+  test "should serialize yaml" do
+    assert_match %r{<preferences type=\"yaml\">--- \n:gem: ruby\n</preferences>}, @contact.to_xml
+  end
+end

activemodel/test/models/contact.rb

+class Contact
+  attr_accessor :name, :age, :created_at, :awesome, :preferences
+end

activerecord/lib/active_record/serialization.rb

 module ActiveRecord #:nodoc:
   module Serialization
-    class Serializer #:nodoc:
-      attr_reader :options
-
-      def initialize(record, options = nil)
-        @record = record
-        @options = options ? options.dup : {}
-      end
-
-      # 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 serializable_attribute_names
-        attribute_names = @record.attribute_names
-
-        if options[:only]
-          options.delete(:except)
-          attribute_names = attribute_names & Array.wrap(options[:only]).collect { |n| n.to_s }
-        else
-          options[:except] = Array.wrap(options[:except]) | Array.wrap(@record.class.inheritance_column)
-          attribute_names = attribute_names - options[:except].collect { |n| n.to_s }
-        end
-
-        attribute_names
-      end
-
-      def serializable_method_names
-        Array.wrap(options[:methods]).inject([]) do |method_attributes, name|
-          method_attributes << name if @record.respond_to?(name.to_s)
-          method_attributes
-        end
-      end
-
-      def serializable_names
-        serializable_attribute_names + serializable_method_names
+    module RecordSerializer #:nodoc:
+      def initialize(*args)
+        super
+        options[:except] |= Array.wrap(@serializable.class.inheritance_column)
       end
 
       # Add associations specified via the <tt>:includes</tt> option.
@@ -53,11 +20,11 @@ def add_includes(&block)
           associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)
 
           for association in associations
-            records = case @record.class.reflect_on_association(association).macro
+            records = case @serializable.class.reflect_on_association(association).macro
             when :has_many, :has_and_belongs_to_many
-              @record.send(association).to_a
+              @serializable.send(association).to_a
             when :has_one, :belongs_to
-              @record.send(association)
+              @serializable.send(association)
             end
 
             unless records.nil?
@@ -71,28 +38,19 @@ def add_includes(&block)
         end
       end
 
-      def serializable_record
-        record = {}
-        serializable_names.each { |name| record[name] = @record.send(name) }
+      def serializable_hash
+        hash = super
 
         add_includes do |association, records, opts|
-          record[association] =
+          hash[association] =
             if records.is_a?(Enumerable)
-              records.collect { |r| self.class.new(r, opts).serializable_record }
+              records.collect { |r| self.class.new(r, opts).serializable_hash }
             else
-              self.class.new(records, opts).serializable_record
+              self.class.new(records, opts).serializable_hash
             end
         end
 
-        record
-      end
-
-      def serialize
-        # overwrite to implement
-      end
-
-      def to_s(&block)
-        serialize(&block)
+        hash
       end
     end
   end

activerecord/lib/active_record/serializers/json_serializer.rb

-require 'active_support/json'
-require 'active_model/naming'
-
 module ActiveRecord #:nodoc:
   module Serialization
     extend ActiveSupport::Concern
+    include ActiveModel::Serializers::JSON
 
-    included do
-      cattr_accessor :include_root_in_json, :instance_writer => false
+    class JSONSerializer < ActiveModel::Serializers::JSON::Serializer
+      include Serialization::RecordSerializer
     end
 
-    # Returns a JSON string representing the model. Some configuration is
-    # available through +options+.
-    #
-    # 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} }
-    #
-    #   ActiveRecord::Base.include_root_in_json = false
-    #   konata.to_json
-    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
-    #         "created_at": "2006/08/01", "awesome": true}
-    #
-    # The remainder of the examples in this section assume include_root_in_json is set to
-    # <tt>false</tt>.
-    #
-    # Without any +options+, the returned JSON string will include all
-    # the model's attributes. For example:
-    #
-    #   konata = User.find(1)
-    #   konata.to_json
-    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
-    #         "created_at": "2006/08/01", "awesome": true}
-    #
-    # The <tt>:only</tt> and <tt>:except</tt> options can be used to limit the attributes
-    # included, and work similar to the +attributes+ method. For example:
-    #
-    #   konata.to_json(:only => [ :id, :name ])
-    #   # => {"id": 1, "name": "Konata Izumi"}
-    #
-    #   konata.to_json(:except => [ :id, :created_at, :age ])
-    #   # => {"name": "Konata Izumi", "awesome": true}
-    #
-    # To include any methods on the model, use <tt>:methods</tt>.
-    #
-    #   konata.to_json(:methods => :permalink)
-    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
-    #         "created_at": "2006/08/01", "awesome": true,
-    #         "permalink": "1-konata-izumi"}
-    #
-    # To include associations, use <tt>:include</tt>.
-    #
-    #   konata.to_json(:include => :posts)
-    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
-    #         "created_at": "2006/08/01", "awesome": true,
-    #         "posts": [{"id": 1, "author_id": 1, "title": "Welcome to the weblog"},
-    #                   {"id": 2, author_id: 1, "title": "So I was thinking"}]}
-    #
-    # 2nd level and higher order associations work as well:
-    #
-    #   konata.to_json(:include => { :posts => {
-    #                                  :include => { :comments => {
-    #                                                :only => :body } },
-    #                                  :only => :title } })
-    #   # => {"id": 1, "name": "Konata Izumi", "age": 16,
-    #         "created_at": "2006/08/01", "awesome": true,
-    #         "posts": [{"comments": [{"body": "1st post!"}, {"body": "Second!"}],
-    #                    "title": "Welcome to the weblog"},
-    #                   {"comments": [{"body": "Don't think too hard"}],
-    #                    "title": "So I was thinking"}]}
     def encode_json(encoder)
-      hash = Serializer.new(self, encoder.options).serializable_record
-      hash = { self.class.model_name.element => hash } if include_root_in_json
-      ActiveSupport::JSON.encode(hash)
-    end
-
-    def as_json(options = nil) self end #:nodoc:
-
-    def from_json(json)
-      self.attributes = ActiveSupport::JSON.decode(json)
-      self
+      JSONSerializer.new(self, encoder.options).to_s
     end
   end
 end

activerecord/lib/active_record/serializers/xml_serializer.rb

@@ -164,7 +164,9 @@ def from_xml(xml)
     end
   end
 
-  class XmlSerializer < ActiveRecord::Serialization::Serializer #:nodoc:
+  class XmlSerializer < ActiveModel::Serializer #:nodoc:
+    include Serialization::RecordSerializer
+
     def builder
       @builder ||= begin
         require 'builder' unless defined? ::Builder
@@ -181,7 +183,7 @@ def builder
     end
 
     def root
-      root = (options[:root] || @record.class.to_s.underscore).to_s
+      root = (options[:root] || @serializable.class.to_s.underscore).to_s
       reformat_name(root)
     end
 
@@ -199,12 +201,12 @@ def reformat_name(name)
     end
 
     def serializable_attributes
-      serializable_attribute_names.collect { |name| Attribute.new(name, @record) }
+      serializable_attribute_names.collect { |name| Attribute.new(name, @serializable) }
     end
 
     def serializable_method_attributes
       Array(options[:methods]).inject([]) do |method_attributes, name|
-        method_attributes << MethodAttribute.new(name.to_s, @record) if @record.respond_to?(name.to_s)
+        method_attributes << MethodAttribute.new(name.to_s, @serializable) if @serializable.respond_to?(name.to_s)
         method_attributes
       end
     end
@@ -254,7 +256,7 @@ def add_associations(association, records, opts)
           end
         end
       else
-        if record = @record.send(association)
+        if record = @serializable.send(association)
           record.to_xml(opts.merge(:root => association))
         end
       end