active_model_serializers 0.7.0 → 0.8.0

data/lib/active_model/serializer.rb

@@ -66,7 +66,15 @@ module ActiveModel
     self._embed = :objects
     class_attribute :_root_embed
 
+    class_attribute :cache
+    class_attribute :perform_caching
+
     class << self
+      # set perform caching like root
+      def cached(value = true)
+        self.perform_caching = value
+      end
+
       # Define attributes to be used in the serialization.
       def attributes(*attrs)
 
@@ -82,7 +90,9 @@ module ActiveModel
       end
 
       def attribute(attr, options={})
-        self._attributes = _attributes.merge(attr => options[:key] || attr.to_s.gsub(/\?$/, '').to_sym)
+        self._attributes = _attributes.merge(attr.is_a?(Hash) ? attr : {attr => options[:key] || attr.to_s.gsub(/\?$/, '').to_sym})
+
+        attr = attr.keys[0] if attr.is_a? Hash
 
         unless method_defined?(attr)
           define_method attr do
@@ -91,6 +101,15 @@ module ActiveModel
         end
 
         define_include_method attr
+
+        # protect inheritance chains and open classes
+        # if a serializer inherits from another OR
+        #  attributes are added later in a classes lifecycle
+        # poison the cache
+        define_method :_fast_attributes do
+          raise NameError
+        end
+
       end
 
       def associate(klass, attrs) #:nodoc:
@@ -184,8 +203,12 @@ module ActiveModel
             attrs[key] = column.type
           else
             # Computed attribute (method on serializer or model). We cannot
-            # infer the type, so we put nil.
-            attrs[key] = nil
+            # infer the type, so we put nil, unless specified in the attribute declaration
+            if name != key
+              attrs[name] = key
+            else
+              attrs[key] = nil
+            end
           end
         end
 
@@ -229,19 +252,64 @@ module ActiveModel
         self._root = name
       end
       alias_method :root=, :root
+
+      # Used internally to create a new serializer object based on controller
+      # settings and options for a given resource. These settings are typically
+      # set during the request lifecycle or by the controller class, and should
+      # not be manually defined for this method.
+      def build_json(controller, resource, options)
+        default_options = controller.send(:default_serializer_options) || {}
+        options = default_options.merge(options || {})
+
+        serializer = options.delete(:serializer) ||
+          (resource.respond_to?(:active_model_serializer) &&
+           resource.active_model_serializer)
+
+        return serializer unless serializer
+
+        if resource.respond_to?(:to_ary)
+          unless serializer <= ActiveModel::ArraySerializer
+            raise ArgumentError.new("#{serializer.name} is not an ArraySerializer. " +
+                                    "You may want to use the :each_serializer option instead.")
+          end
+
+          if options[:root] != false && serializer.root != false
+            # the serializer for an Array is ActiveModel::ArraySerializer
+            options[:root] ||= serializer.root || controller.controller_name
+          end
+        end
+
+        options[:scope] = controller.serialization_scope unless options.has_key?(:scope)
+        options[:scope_name] = controller._serialization_scope
+        options[:url_options] = controller.url_options
+
+        serializer.new(resource, options)
+      end
     end
 
     attr_reader :object, :options
 
     def initialize(object, options={})
       @object, @options = object, options
+
+      scope_name = @options[:scope_name]
+      if scope_name && !respond_to?(scope_name)
+        self.class.class_eval do
+          define_method scope_name, lambda { scope }
+        end
+      end
     end
 
     def root_name
       return false if self._root == false
-      
+
       class_name = self.class.name.demodulize.underscore.sub(/_serializer$/, '').to_sym unless self.class.name.blank?
-      self._root || class_name
+
+      if self._root == true
+        class_name
+      else
+        self._root || class_name
+      end
     end
 
     def url_options
@@ -256,6 +324,16 @@ module ActiveModel
       hash[meta_key] = @options[:meta] if @options.has_key?(:meta)
     end
 
+    def to_json(*args)
+      if perform_caching?
+        cache.fetch expand_cache_key([self.class.to_s.underscore, cache_key, 'to-json']) do
+          super
+        end
+      else
+        super
+      end
+    end
+
     # Returns a json representation of the serializable
     # object including the root.
     def as_json(options={})
@@ -274,13 +352,12 @@ module ActiveModel
     # Returns a hash representation of the serializable
     # object without the root.
     def serializable_hash
-      return nil if @object.nil?
-      instrument(:serialize, :serializer => self.class.name) do
-        @node = attributes
-        instrument :associations do
-          include_associations! if _embed
+      if perform_caching?
+        cache.fetch expand_cache_key([self.class.to_s.underscore, cache_key, 'serializable-hash']) do
+          _serializable_hash
         end
-        @node
+      else
+        _serializable_hash
       end
     end
 
@@ -291,6 +368,8 @@ module ActiveModel
     end
 
     def include?(name)
+      return false if options.key?(:only) && !Array(options[:only]).include?(name)
+      return false if options.key?(:except) && Array(options[:except]).include?(name)
       send INCLUDE_METHODS[name]
     end
 
@@ -372,13 +451,19 @@ module ActiveModel
     # Returns a hash representation of the serializable
     # object attributes.
     def attributes
-      hash = {}
+      _fast_attributes
+      rescue NameError
+        method = "def _fast_attributes\n"
 
-      _attributes.each do |name,key|
-        hash[key] = read_attribute_for_serialization(name) if include?(name)
-      end
+        method << "  h = {}\n"
 
-      hash
+        _attributes.each do |name,key|
+          method << "  h[:\"#{key}\"] = read_attribute_for_serialization(:\"#{name}\") if include?(:\"#{name}\")\n"
+        end
+        method << "  h\nend"
+
+        self.class.class_eval method
+        _fast_attributes
     end
 
     # Returns options[:scope]
@@ -388,6 +473,21 @@ module ActiveModel
 
     alias :read_attribute_for_serialization :send
 
+    def _serializable_hash
+      return nil if @object.nil?
+      @node = attributes
+      include_associations! if _embed
+      @node
+    end
+
+    def perform_caching?
+      perform_caching && cache && respond_to?(:cache_key)
+    end
+
+    def expand_cache_key(*args)
+      ActiveSupport::Cache.expand_cache_key(args)
+    end
+
     # Use ActiveSupport::Notifications to send events to external systems.
     # The event name is: name.class_name.serializer
     def instrument(name, payload = {}, &block)
@@ -395,4 +495,20 @@ module ActiveModel
       ActiveSupport::Notifications.instrument(event_name, payload, &block)
     end
   end
+
+  # DefaultSerializer
+  #
+  # Provides a constant interface for all items, particularly
+  # for ArraySerializer.
+  class DefaultSerializer
+    attr_reader :object, :options
+
+    def initialize(object, options={})
+      @object, @options = object, options
+    end
+
+    def serializable_hash
+      @object.as_json(@options)
+    end
+  end
 end

data/lib/active_model/serializer/associations.rb

@@ -17,6 +17,14 @@ module ActiveModel
             end
 
             self.options = class_options
+
+            # cache the root so we can reuse it without falling back on a per-instance basis
+            begin
+              self.options[:root] ||= self.new(name, nil).root
+            rescue
+              # this could fail if it needs a valid source, for example a polymorphic association
+            end
+
           end
         end
 
@@ -64,11 +72,11 @@ module ActiveModel
         end
 
         def embed_ids?
-          option(:embed, source_serializer._embed) == :ids
+          [:id, :ids].include? option(:embed, source_serializer._embed)
         end
 
         def embed_objects?
-          option(:embed, source_serializer._embed) == :objects
+          [:object, :objects].include? option(:embed, source_serializer._embed)
         end
 
         def embed_in_root?
@@ -124,12 +132,9 @@ module ActiveModel
         end
 
         def serialize_ids
-          # Use pluck or select_columns if available
-          # return collection.ids if collection.respond_to?(:ids)
-          ids_key = "#{key.to_s.singularize}_ids"
-
-          if !option(:include) && !option(:embed_key) && source_serializer.object.respond_to?(ids_key)
-            source_serializer.object.send(ids_key)
+          ids_key = "#{@name.to_s.singularize}_ids".to_sym
+          if !option(:embed_key) && !source_serializer.respond_to?(@name.to_s) && source_serializer.object.respond_to?(ids_key)
+            source_serializer.object.read_attribute_for_serialization(ids_key)
           else
             associated_object.map do |item|
               item.read_attribute_for_serialization(embed_key)
@@ -203,6 +208,8 @@ module ActiveModel
         end
 
         def serialize_ids
+          id_key = "#{@name}_id".to_sym
+
           if polymorphic?
             if associated_object
               {
@@ -212,8 +219,8 @@ module ActiveModel
             else
               nil
             end
-          elsif !option(:embed_key) && source_serializer.object.respond_to?("#{name}_id")
-            source_serializer.object.send("#{name}_id")
+          elsif !option(:embed_key) && !source_serializer.respond_to?(@name.to_s) && source_serializer.object.respond_to?(id_key)
+            source_serializer.object.read_attribute_for_serialization(id_key)
           elsif associated_object
             associated_object.read_attribute_for_serialization(embed_key)
           else

data/lib/active_model/serializers/version.rb

@@ -1,5 +1,5 @@
 module ActiveModel
   class Serializer
-    VERSION = "0.7.0"
+    VERSION = "0.8.0"
   end
 end

data/lib/active_model_serializers.rb

@@ -15,14 +15,24 @@ if defined?(Rails)
 
         Rails::Generators.configure!(app.config.generators)
         Rails::Generators.hidden_namespaces.uniq!
-        require "generators/resource_override"
+        require_relative "generators/resource_override"
       end
 
       initializer "include_routes.active_model_serializer" do |app|
         ActiveSupport.on_load(:active_model_serializers) do
-          include app.routes.url_helpers
+          include AbstractController::UrlFor
+          extend ::AbstractController::Railties::RoutesHelpers.with(app.routes)
+          include app.routes.mounted_helpers
         end
       end
+
+      initializer "caching.active_model_serializer" do |app|
+        ActiveModel::Serializer.perform_caching = app.config.action_controller.perform_caching
+        ActiveModel::ArraySerializer.perform_caching = app.config.action_controller.perform_caching
+
+        ActiveModel::Serializer.cache = Rails.cache
+        ActiveModel::ArraySerializer.cache = Rails.cache
+      end
     end
   end
 end
@@ -54,10 +64,6 @@ module ActiveModel::SerializerSupport
   alias :read_attribute_for_serialization :send
 end
 
-ActiveSupport.on_load(:active_record) do
-  include ActiveModel::SerializerSupport
-end
-
 module ActiveModel::ArraySerializerSupport
   def active_model_serializer
     ActiveModel::ArraySerializer
@@ -67,8 +73,14 @@ end
 Array.send(:include, ActiveModel::ArraySerializerSupport)
 Set.send(:include, ActiveModel::ArraySerializerSupport)
 
-ActiveSupport.on_load(:active_record) do
-  ActiveRecord::Relation.send(:include, ActiveModel::ArraySerializerSupport)
+{
+  :active_record => 'ActiveRecord::Relation',
+  :mongoid => 'Mongoid::Criteria'
+}.each do |orm, rel_class|
+  ActiveSupport.on_load(orm) do
+    include ActiveModel::SerializerSupport
+    rel_class.constantize.send(:include, ActiveModel::ArraySerializerSupport)
+  end
 end
 
 begin

data/lib/active_record/serializer_override.rb

@@ -0,0 +1,16 @@
+# We do not recommend that you use AM::S in this way, but if you must, here
+# is a mixin that overrides ActiveRecord::Base#to_json and #as_json.
+
+module ActiveRecord
+  module SerializerOverride
+    def to_json options = {}
+      active_model_serializer.new(self).to_json options
+    end
+
+    def as_json options={}
+      active_model_serializer.new(self).as_json options
+    end
+  end
+
+  Base.send(:include, SerializerOverride)
+end

data/lib/generators/serializer/serializer_generator.rb

@@ -12,9 +12,10 @@ module Rails
         template 'serializer.rb', File.join('app/serializers', class_path, "#{file_name}_serializer.rb")
       end
 
-      # hook_for :test_framework
-
       private
+      def generate_id_method
+        RUBY_VERSION =~ /1\.8/
+      end
 
       def attributes_names
         [:id] + attributes.select { |attr| !attr.reference? }.map { |a| a.name.to_sym }

data/lib/generators/serializer/templates/serializer.rb

@@ -4,5 +4,16 @@ class <%= class_name %>Serializer < <%= parent_class_name %>
 <% association_names.each do |attribute| -%>
   has_one :<%= attribute %>
 <% end -%>
+<% if generate_id_method %>
+
+  # due to the difference between 1.8 and 1.9 with respect to #id and
+  # #object_id, we recommend that if you wish to serialize id columns, you
+  # do this. Feel free to remove this if you don't feel that it's appropriate.
+  #
+  # For more: https://github.com/rails-api/active_model_serializers/issues/127
+  def id
+    object.read_attribute_for_serialization(:id)
+  end
+<% end -%>
 end
 <% end -%>

data/test/array_serializer_test.rb

@@ -51,5 +51,4 @@ class ArraySerializerTest < ActiveModel::TestCase
       { :title => "Post2" }
     ], serializer.as_json)
   end
-
 end

data/test/association_test.rb

@@ -379,6 +379,109 @@ class AssociationTest < ActiveModel::TestCase
 
       assert_equal 1, serialized_times
     end
+
+    def test_include_with_read_association_id_for_serialization_hook
+      @post_serializer_class.class_eval do
+        has_one :comment, :embed => :ids, :include => true
+      end
+
+      association_name = nil
+      @post.class_eval do
+        define_method :read_attribute_for_serialization, lambda { |name|
+          association_name = name
+          send(name)
+        }
+        define_method :comment_id, lambda {
+          @attributes[:comment].id
+        }
+      end
+
+      include_bare! :comment
+
+      assert_equal({
+        :comment_id => 1
+      }, @hash)
+    end
+
+    def test_include_with_read_association_ids_for_serialization_hook
+      @post_serializer_class.class_eval do
+        has_many :comments, :embed => :ids, :include => false
+      end
+
+      association_name = nil
+      @post.class_eval do
+        define_method :read_attribute_for_serialization, lambda { |name|
+          association_name = name
+          send(name)
+        }
+        define_method :comment_ids, lambda {
+          @attributes[:comments].map(&:id)
+        }
+      end
+
+      include_bare! :comments
+
+      assert_equal({
+        :comment_ids => [1]
+      }, @hash)
+    end
+  end
+
+  class RecursiveTest < AssociationTest
+    class BarSerializer < ActiveModel::Serializer; end
+
+    class FooSerializer < ActiveModel::Serializer
+      root :foos
+      attributes :id
+      has_many :bars, :serializer => BarSerializer, :root => :bars, :embed => :ids, :include => true
+    end
+
+    class BarSerializer < ActiveModel::Serializer
+      root :bars
+      attributes :id
+      has_many :foos, :serializer => FooSerializer, :root => :foos, :embed => :ids, :include => true
+    end
+
+    class Foo < Model
+      def active_model_serializer; FooSerializer; end
+    end
+
+    class Bar < Model
+      def active_model_serializer; BarSerializer; end
+    end
+
+    def setup
+      super
+
+      foo = Foo.new(:id => 1)
+      bar = Bar.new(:id => 2)
+
+      foo.bars = [ bar ]
+      bar.foos = [ foo ]
+
+      collection = [ foo ]
+
+      @serializer = collection.active_model_serializer.new(collection, :root => :foos)
+    end
+
+    def test_mutual_relation_result
+      assert_equal({
+        :foos => [{
+          :bar_ids => [ 2 ],
+          :id => 1
+        }],
+        :bars => [{
+          :foo_ids => [ 1 ],
+          :id => 2
+        }]
+      }, @serializer.as_json)
+    end
+
+    def test_mutual_relation_does_not_raise_error
+      assert_nothing_raised SystemStackError, 'stack level too deep' do
+        @serializer.as_json
+      end
+    end
   end
 
   class InclusionTest < AssociationTest