active_model_serializers 0.5.2 → 0.6.0

data/lib/active_model/ordered_set.rb

@@ -0,0 +1,25 @@
+module ActiveModel
+  class OrderedSet
+    def initialize(array)
+      @array = array
+      @hash = {}
+
+      array.each do |item|
+        @hash[item] = true
+      end
+    end
+
+    def merge!(other)
+      other.each do |item|
+        next if @hash.key?(item)
+
+        @hash[item] = true
+        @array.push item
+      end
+    end
+
+    def to_a
+      @array
+    end
+  end
+end

data/lib/active_model/serializer.rb

@@ -3,78 +3,11 @@ require "active_support/core_ext/module/anonymous"
 require "set"
 
 module ActiveModel
-  class OrderedSet
-    def initialize(array)
-      @array = array
-      @hash = {}
-
-      array.each do |item|
-        @hash[item] = true
-      end
-    end
-
-    def merge!(other)
-      other.each do |item|
-        next if @hash.key?(item)
-
-        @hash[item] = true
-        @array.push item
-      end
-    end
-
-    def to_a
-      @array
-    end
-  end
-
-  # Active Model Array Serializer
-  #
-  # It serializes an array checking if each element that implements
-  # the +active_model_serializer+ method.
-  class ArraySerializer
-    attr_reader :object, :options
-
-    def initialize(object, options={})
-      @object, @options = object, options
-    end
-
-    def serializable_array
-      @object.map do |item|
-        if item.respond_to?(:active_model_serializer) && (serializer = item.active_model_serializer)
-          serializer.new(item, @options)
-        else
-          item
-        end
-      end
-    end
-
-    def as_json(*args)
-      @options[:hash] = hash = {}
-      @options[:unique_values] = {}
-
-      array = serializable_array.map do |item|
-        if item.is_a?(Hash)
-          item
-        elsif item.respond_to?(:serializable_hash)
-          item.serializable_hash
-        else
-          item.as_json
-        end
-      end
-
-      if root = @options[:root]
-        hash.merge!(root => array)
-      else
-        array
-      end
-    end
-  end
-
   # Active Model Serializer
   #
   # Provides a basic serializer implementation that allows you to easily
   # control how a given object is going to be serialized. On initialization,
-  # it expects to object as arguments, a resource and options. For example,
+  # it expects two objects as arguments, a resource and options. For example,
   # one may do in a controller:
   #
   #     PostSerializer.new(@post, :scope => current_user).to_json
@@ -83,7 +16,7 @@ module ActiveModel
   # in for authorization purposes.
   #
   # We use the scope to check if a given attribute should be serialized or not.
-  # For example, some attributes maybe only be returned if +current_user+ is the
+  # For example, some attributes may only be returned if +current_user+ is the
   # author of the post:
   #
   #     class PostSerializer < ActiveModel::Serializer
@@ -99,11 +32,26 @@ module ActiveModel
   #       end
   #
   #       def author?
-  #         post.author == options[:scope]
+  #         post.author == scope
   #       end
   #     end
   #
   class Serializer
+    INCLUDE_METHODS = {}
+    INSTRUMENT = { :serialize => :"serialize.serializer", :associations => :"associations.serializer" }
+
+    class IncludeError < StandardError
+      attr_reader :source, :association
+
+      def initialize(source, association)
+        @source, @association = source, association
+      end
+
+      def to_s
+        "Cannot serialize #{association} when #{source} does not have a root!"
+      end
+    end
+
     module Associations #:nodoc:
       class Config #:nodoc:
         class_attribute :options
@@ -178,6 +126,10 @@ module ActiveModel
           option(:include, source_serializer._root_embed)
         end
 
+        def embeddable?
+          !associated_object.nil?
+        end
+
       protected
 
         def find_serializable(object)
@@ -212,13 +164,41 @@ module ActiveModel
       end
 
       class HasOne < Config #:nodoc:
+        def embeddable?
+          if polymorphic? && associated_object.nil?
+            false
+          else
+            true
+          end
+        end
+
+        def polymorphic?
+          option :polymorphic
+        end
+
+        def polymorphic_key
+          associated_object.class.to_s.demodulize.underscore.to_sym
+        end
+
         def plural_key
-          key.to_s.pluralize.to_sym
+          if polymorphic?
+            associated_object.class.to_s.pluralize.demodulize.underscore.to_sym
+          else
+            key.to_s.pluralize.to_sym
+          end
         end
 
         def serialize
           object = associated_object
-          object && find_serializable(object).serializable_hash
+
+          if object && polymorphic?
+            { 
+              :type => polymorphic_key,
+              polymorphic_key => find_serializable(object).serializable_hash
+            }
+          elsif object
+            find_serializable(object).serializable_hash
+          end
         end
 
         def serialize_many
@@ -228,7 +208,14 @@ module ActiveModel
         end
 
         def serialize_ids
-          if object = associated_object
+          object = associated_object
+
+          if object && polymorphic?
+            { 
+              :type => polymorphic_key,
+              :id => object.read_attribute_for_serialization(:id)
+            }
+          elsif object
             object.read_attribute_for_serialization(:id)
           else
             nil
@@ -259,11 +246,15 @@ module ActiveModel
       end
 
       def attribute(attr, options={})
-        self._attributes = _attributes.merge(attr => options[:key] || attr)
+        self._attributes = _attributes.merge(attr => options[:key] || attr.to_s.gsub(/\?$/, '').to_sym)
 
         unless method_defined?(attr)
-          class_eval "def #{attr}() object.read_attribute_for_serialization(:#{attr}) end", __FILE__, __LINE__
+          define_method attr do
+            object.read_attribute_for_serialization(attr.to_sym)
+          end
         end
+
+        define_include_method attr
       end
 
       def associate(klass, attrs) #:nodoc:
@@ -272,13 +263,29 @@ module ActiveModel
 
         attrs.each do |attr|
           unless method_defined?(attr)
-            class_eval "def #{attr}() object.#{attr} end", __FILE__, __LINE__
+            define_method attr do
+              object.send attr
+            end
           end
 
+          define_include_method attr
+
           self._associations[attr] = klass.refine(attr, options)
         end
       end
 
+      def define_include_method(name)
+        method = "include_#{name}?".to_sym
+
+        INCLUDE_METHODS[name] = method
+
+        unless method_defined?(method)
+          define_method method do
+            true
+          end
+        end
+      end
+
       # Defines an association in the object should be rendered.
       #
       # The serializer object should implement the association name
@@ -389,13 +396,12 @@ module ActiveModel
     end
 
     def url_options
-      @options[:url_options]
+      @options[:url_options] || {}
     end
 
     # Returns a json representation of the serializable
     # object including the root.
-    def as_json(options=nil)
-      options ||= {}
+    def as_json(options={})
       if root = options.fetch(:root, @options.fetch(:root, _root))
         @options[:hash] = hash = {}
         @options[:unique_values] = {}
@@ -411,34 +417,22 @@ module ActiveModel
     # object without the root.
     def serializable_hash
       instrument(:serialize, :serializer => self.class.name) do
-        node = attributes
+        @node = attributes
         instrument :associations do
-          include_associations!(node) if _embed
+          include_associations! if _embed
         end
-        node
+        @node
       end
     end
 
-    def include_associations!(node)
-      _associations.each do |attr, klass|
-        opts = { :node => node }
-
-        if options.include?(:include) || options.include?(:exclude)
-          opts[:include] = included_association?(attr)
-        end
-
-        include! attr, opts
+    def include_associations!
+      _associations.each_key do |name|
+        include!(name) if include?(name)
       end
     end
 
-    def included_association?(name)
-      if options.key?(:include)
-        options[:include].include?(name)
-      elsif options.key?(:exclude)
-        !options[:exclude].include?(name)
-      else
-        true
-      end
+    def include?(name)
+      send INCLUDE_METHODS[name]
     end
 
     def include!(name, options={})
@@ -460,9 +454,17 @@ module ActiveModel
           @options[:unique_values] ||= {}
         end
 
-      node = options[:node]
+      node = options[:node] ||= @node
       value = options[:value]
 
+      if options[:include] == nil
+        if @options.key?(:include)
+          options[:include] = @options[:include].include?(name)
+        elsif @options.include?(:exclude)
+          options[:include] = !@options[:exclude].include?(name)
+        end
+      end
+
       association_class =
         if klass = _associations[name]
           klass
@@ -477,7 +479,9 @@ module ActiveModel
       if association.embed_ids?
         node[association.key] = association.serialize_ids
 
-        if association.embed_in_root?
+        if association.embed_in_root? && hash.nil?
+          raise IncludeError.new(self.class, association.name)
+        elsif association.embed_in_root? && association.embeddable?
           merge_association hash, association.root, association.serialize_many, unique_values
         end
       elsif association.embed_objects?
@@ -510,25 +514,24 @@ module ActiveModel
       hash = {}
 
       _attributes.each do |name,key|
-        hash[key] = read_attribute_for_serialization(name)
+        hash[key] = read_attribute_for_serialization(name) if include?(name)
       end
 
       hash
     end
 
+    # Returns options[:scope]
+    def scope
+      @options[:scope]
+    end
+
     alias :read_attribute_for_serialization :send
 
     # Use ActiveSupport::Notifications to send events to external systems.
     # The event name is: name.class_name.serializer
     def instrument(name, payload = {}, &block)
-      ActiveSupport::Notifications.instrument("#{name}.serializer", payload, &block)
+      event_name = INSTRUMENT[name]
+      ActiveSupport::Notifications.instrument(event_name, payload, &block)
     end
   end
 end
-
-class Array
-  # Array uses ActiveModel::ArraySerializer.
-  def active_model_serializer
-    ActiveModel::ArraySerializer
-  end
-end

data/lib/active_model/serializers/version.rb

@@ -1,5 +1,5 @@
 module ActiveModel
   class Serializer
-    VERSION = "0.5.2"
+    VERSION = "0.6.0"
   end
 end

data/lib/active_model_serializers.rb

@@ -2,7 +2,10 @@ require "active_support"
 require "active_support/core_ext/string/inflections"
 require "active_support/notifications"
 require "active_model"
+require "active_model/ordered_set"
+require "active_model/array_serializer"
 require "active_model/serializer"
+require "set"
 
 if defined?(Rails)
   module ActiveModel
@@ -11,6 +14,7 @@ if defined?(Rails)
         app ||= Rails.application # Rails 3.0.x does not yield `app`
 
         Rails::Generators.configure!(app.config.generators)
+        Rails::Generators.hidden_namespaces.uniq!
         require "generators/resource_override"
       end
 
@@ -56,6 +60,19 @@ ActiveSupport.on_load(:active_record) do
   include ActiveModel::SerializerSupport
 end
 
+module ActiveModel::ArraySerializerSupport
+  def active_model_serializer
+    ActiveModel::ArraySerializer
+  end
+end
+
+Array.send(:include, ActiveModel::ArraySerializerSupport)
+Set.send(:include, ActiveModel::ArraySerializerSupport)
+
+ActiveSupport.on_load(:active_record) do
+  ActiveRecord::Relation.send(:include, ActiveModel::ArraySerializerSupport)
+end
+
 begin
   require 'action_controller'
   require 'action_controller/serialization'

data/test/no_serialization_scope_test.rb

@@ -0,0 +1,34 @@
+require "test_helper"
+
+class NoSerializationScopeTest < ActionController::TestCase
+  class ScopeSerializer
+    def initialize(object, options)
+      @object, @options = object, options
+    end
+
+    def as_json(*)
+      { :scope => @options[:scope].as_json }
+    end
+  end
+
+  class ScopeSerializable
+    def active_model_serializer
+      ScopeSerializer
+    end
+  end
+
+  class NoSerializationScopeController < ActionController::Base
+    serialization_scope nil
+
+    def index
+      render :json => ScopeSerializable.new
+    end
+  end
+
+  tests NoSerializationScopeController
+
+  def test_disabled_serialization_scope
+    get :index
+    assert_equal '{"scope":null}', @response.body
+  end
+end