Merge branch 'master' of git://github.com/rails/rails

3 files changed, 24 insertions, 141 deletions

diff --git a/activerecord/lib/active_record/serialization.rb b/activerecord/lib/active_record/serialization.rb
index 23d085bea9..94f1e8f1fd 100644
--- a/activerecord/lib/active_record/serialization.rb
+++ b/activerecord/lib/active_record/serialization.rb
@@ -1,42 +1,9 @@
 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 @@ module ActiveRecord #:nodoc:
           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 @@ module ActiveRecord #:nodoc:
         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
diff --git a/activerecord/lib/active_record/serializers/json_serializer.rb b/activerecord/lib/active_record/serializers/json_serializer.rb
index 21afcd6e5c..63bf42c09d 100644
--- a/activerecord/lib/active_record/serializers/json_serializer.rb
+++ b/activerecord/lib/active_record/serializers/json_serializer.rb
@@ -1,91 +1,14 @@
-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
diff --git a/activerecord/lib/active_record/serializers/xml_serializer.rb b/activerecord/lib/active_record/serializers/xml_serializer.rb
index 4eaf9531e2..c3811caa53 100644
--- a/activerecord/lib/active_record/serializers/xml_serializer.rb
+++ b/activerecord/lib/active_record/serializers/xml_serializer.rb
@@ -164,7 +164,9 @@ module ActiveRecord #:nodoc:
     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 @@ module ActiveRecord #:nodoc:
     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 @@ module ActiveRecord #:nodoc:
     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 @@ module ActiveRecord #:nodoc:
           end
         end
       else
-        if record = @record.send(association)
+        if record = @serializable.send(association)
           record.to_xml(opts.merge(:root => association))
         end
       end