Break up concerns for choosing what attributes should be serialized and the actual serializer

1 files changed, 39 insertions, 41 deletions

diff --git a/activerecord/lib/active_record/serialization.rb b/activerecord/lib/active_record/serialization.rb
index 94f1e8f1fd..b49471f7ab 100644
--- a/activerecord/lib/active_record/serialization.rb
+++ b/activerecord/lib/active_record/serialization.rb
@@ -1,60 +1,58 @@
 module ActiveRecord #:nodoc:
   module Serialization
-    module RecordSerializer #:nodoc:
-      def initialize(*args)
-        super
-        options[:except] |= Array.wrap(@serializable.class.inheritance_column)
+    extend ActiveSupport::Concern
+    include ActiveModel::Serializers::JSON
+
+    def serializable_hash(options = nil)
+      options ||= {}
+
+      options[:except] = Array.wrap(options[:except]).map { |n| n.to_s }
+      options[:except] |= Array.wrap(self.class.inheritance_column)
+
+      hash = super(options)
+
+      serializable_add_includes(options) do |association, records, opts|
+        hash[association] = records.is_a?(Enumerable) ?
+          records.map { |r| r.serializable_hash(opts) } :
+          records.serializable_hash(opts)
       end
 
+      hash
+    end
+
+    private
       # Add associations specified via the <tt>:includes</tt> option.
       # Expects a block that takes as arguments:
       #   +association+ - name of the association
       #   +records+     - the association record(s) to be serialized
       #   +opts+        - options for the association records
-      def add_includes(&block)
-        if include_associations = options.delete(:include)
-          base_only_or_except = { :except => options[:except],
-                                  :only => options[:only] }
-
-          include_has_options = include_associations.is_a?(Hash)
-          associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)
-
-          for association in associations
-            records = case @serializable.class.reflect_on_association(association).macro
-            when :has_many, :has_and_belongs_to_many
-              @serializable.send(association).to_a
-            when :has_one, :belongs_to
-              @serializable.send(association)
-            end
-
-            unless records.nil?
-              association_options = include_has_options ? include_associations[association] : base_only_or_except
-              opts = options.merge(association_options)
-              yield(association, records, opts)
-            end
-          end
+      def serializable_add_includes(options = {})
+        return unless include_associations = options.delete(:include)
 
-          options[:include] = include_associations
-        end
-      end
+        base_only_or_except = { :except => options[:except],
+                                :only => options[:only] }
+
+        include_has_options = include_associations.is_a?(Hash)
+        associations = include_has_options ? include_associations.keys : Array.wrap(include_associations)
 
-      def serializable_hash
-        hash = super
+        for association in associations
+          records = case self.class.reflect_on_association(association).macro
+          when :has_many, :has_and_belongs_to_many
+            send(association).to_a
+          when :has_one, :belongs_to
+            send(association)
+          end
 
-        add_includes do |association, records, opts|
-          hash[association] =
-            if records.is_a?(Enumerable)
-              records.collect { |r| self.class.new(r, opts).serializable_hash }
-            else
-              self.class.new(records, opts).serializable_hash
-            end
+          unless records.nil?
+            association_options = include_has_options ? include_associations[association] : base_only_or_except
+            opts = options.merge(association_options)
+            yield(association, records, opts)
+          end
         end
 
-        hash
+        options[:include] = include_associations
       end
-    end
   end
 end
 
 require 'active_record/serializers/xml_serializer'
-require 'active_record/serializers/json_serializer'