active_model_serializers 0.10.0.rc2 → 0.10.0.rc3

data/lib/active_model/serializer/adapter/json_api/pagination_links.rb

@@ -0,0 +1,50 @@
+class ActiveModel::Serializer::Adapter::JsonApi::PaginationLinks
+          FIRST_PAGE = 1
+
+          attr_reader :collection, :context
+
+          def initialize(collection, context)
+            @collection = collection
+            @context = context
+          end
+
+          def serializable_hash(options = {})
+            pages_from.each_with_object({}) do |(key, value), hash|
+              params = query_parameters.merge(page: { number: value, size: collection.size }).to_query
+
+              hash[key] = "#{url(options)}?#{params}"
+            end
+          end
+
+          private
+
+          def pages_from
+            return {} if collection.total_pages == FIRST_PAGE
+
+            {}.tap do |pages|
+              pages[:self] = collection.current_page
+
+              unless collection.current_page == FIRST_PAGE
+                pages[:first] = FIRST_PAGE
+                pages[:prev]  = collection.current_page - FIRST_PAGE
+              end
+
+              unless collection.current_page == collection.total_pages
+                pages[:next] = collection.current_page + FIRST_PAGE
+                pages[:last] = collection.total_pages
+              end
+            end
+          end
+
+          def url(options)
+            @url ||= options.fetch(:links, {}).fetch(:self, nil) || original_url
+          end
+
+          def original_url
+            @original_url ||= context.original_url[/\A[^?]+/]
+          end
+
+          def query_parameters
+            @query_parameters ||= context.query_parameters
+          end
+end

data/lib/active_model/serializer/adapter/null.rb

@@ -1,11 +1,5 @@
-module ActiveModel
-  class Serializer
-    class Adapter
-      class Null < Adapter
-        def serializable_hash(options = {})
+class ActiveModel::Serializer::Adapter::Null < ActiveModel::Serializer::Adapter
+        def serializable_hash(options = nil)
           {}
         end
-      end
-    end
-  end
 end

data/lib/active_model/serializer/array_serializer.rb

@@ -1,34 +1,39 @@
 module ActiveModel
   class Serializer
     class ArraySerializer
+      NoSerializerError = Class.new(StandardError)
       include Enumerable
-      delegate :each, to: :@objects
+      delegate :each, to: :@serializers
 
-      attr_reader :meta, :meta_key
+      attr_reader :object, :root, :meta, :meta_key
 
-      def initialize(objects, options = {})
-        @resource = objects
-        @objects  = objects.map do |object|
-          serializer_class = options.fetch(
-            :serializer,
-            ActiveModel::Serializer.serializer_for(object)
-          )
-          serializer_class.new(object, options.except(:serializer))
+      def initialize(resources, options = {})
+        @root = options[:root]
+        @object = resources
+        @serializers = resources.map do |resource|
+          serializer_class = options.fetch(:serializer) {
+            ActiveModel::Serializer.serializer_for(resource)
+          }
+
+          if serializer_class.nil?
+            fail NoSerializerError, "No serializer found for resource: #{resource.inspect}"
+          else
+            serializer_class.new(resource, options.except(:serializer))
+          end
         end
         @meta     = options[:meta]
         @meta_key = options[:meta_key]
       end
 
       def json_key
-        if @objects.first
-          @objects.first.json_key.pluralize
-        else
-          @resource.name.downcase.pluralize if @resource.try(:name)
-        end
+        key = root || @serializers.first.try(:json_key) || object.try(:name).try(:underscore)
+        key.try(:pluralize)
       end
 
-      def root=(root)
-        @objects.first.root = root if @objects.first
+      def paginated?
+        object.respond_to?(:current_page) &&
+          object.respond_to?(:total_pages) &&
+          object.respond_to?(:size)
       end
     end
   end

data/lib/active_model/serializer/association.rb

@@ -0,0 +1,20 @@
+module ActiveModel
+  class Serializer
+    # This class hold all information about serializer's association.
+    #
+    # @param [Symbol] name
+    # @param [ActiveModel::Serializer] serializer
+    # @param [Hash{Symbol => Object}] options
+    #
+    # @example
+    #  Association.new(:comments, CommentSummarySerializer)
+    #
+    Association = Struct.new(:name, :serializer, :options) do
+      # @return [Symbol]
+      #
+      def key
+        options.fetch(:key, name)
+      end
+    end
+  end
+end

data/lib/active_model/serializer/associations.rb

@@ -0,0 +1,97 @@
+module ActiveModel
+  class Serializer
+    # Defines an association in the object should be rendered.
+    #
+    # The serializer object should implement the association name
+    # as a method which should return an array when invoked. If a method
+    # with the association name does not exist, the association name is
+    # dispatched to the serialized object.
+    #
+    module Associations
+      extend ActiveSupport::Concern
+
+      included do |base|
+        class << base
+          attr_accessor :_reflections
+        end
+
+        autoload :Association
+        autoload :Reflection
+        autoload :SingularReflection
+        autoload :CollectionReflection
+        autoload :BelongsToReflection
+        autoload :HasOneReflection
+        autoload :HasManyReflection
+      end
+
+      module ClassMethods
+        def inherited(base)
+          base._reflections = self._reflections.try(:dup) || []
+        end
+
+        # @param [Symbol] name of the association
+        # @param [Hash<Symbol => any>] options for the reflection
+        # @return [void]
+        #
+        # @example
+        #  has_many :comments, serializer: CommentSummarySerializer
+        #
+        def has_many(name, options = {})
+          associate HasManyReflection.new(name, options)
+        end
+
+        # @param [Symbol] name of the association
+        # @param [Hash<Symbol => any>] options for the reflection
+        # @return [void]
+        #
+        # @example
+        #  belongs_to :author, serializer: AuthorSerializer
+        #
+        def belongs_to(name, options = {})
+          associate BelongsToReflection.new(name, options)
+        end
+
+        # @param [Symbol] name of the association
+        # @param [Hash<Symbol => any>] options for the reflection
+        # @return [void]
+        #
+        # @example
+        #  has_one :author, serializer: AuthorSerializer
+        #
+        def has_one(name, options = {})
+          associate HasOneReflection.new(name, options)
+        end
+
+        private
+
+        # Add reflection and define {name} accessor.
+        # @param [ActiveModel::Serializer::Reflection] reflection
+        # @return [void]
+        #
+        # @api private
+        #
+        def associate(reflection)
+          self._reflections = _reflections.dup
+
+          define_method reflection.name do
+            object.send reflection.name
+          end unless method_defined?(reflection.name)
+
+          self._reflections << reflection
+        end
+      end
+
+      # @return [Enumerator<Association>]
+      #
+      def associations
+        return unless object
+
+        Enumerator.new do |y|
+          self.class._reflections.each do |reflection|
+            y.yield reflection.build_association(self, options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_model/serializer/belongs_to_reflection.rb

@@ -0,0 +1,10 @@
+module ActiveModel
+  class Serializer
+    # @api private
+    class BelongsToReflection < SingularReflection
+      def macro
+        :belongs_to
+      end
+    end
+  end
+end

data/lib/active_model/serializer/collection_reflection.rb

@@ -0,0 +1,7 @@
+module ActiveModel
+  class Serializer
+    # @api private
+    class CollectionReflection < Reflection
+    end
+  end
+end

data/lib/active_model/serializer/configuration.rb

@@ -7,6 +7,7 @@ module ActiveModel
       included do |base|
         base.config.array_serializer = ActiveModel::Serializer::ArraySerializer
         base.config.adapter = :flatten_json
+        base.config.jsonapi_resource_type = :plural
       end
     end
   end

data/lib/active_model/serializer/fieldset.rb

@@ -1,7 +1,6 @@
 module ActiveModel
   class Serializer
     class Fieldset
-
       def initialize(fields, root = nil)
         @root       = root
         @raw_fields = fields
@@ -16,16 +15,18 @@ module ActiveModel
         fields[key.to_sym] || fields[key.pluralize.to_sym]
       end
 
-    private
+      private
 
-      attr_reader :raw_fields, :root
+      ActiveModelSerializers.silence_warnings do
+        attr_reader :raw_fields, :root
+      end
 
       def parsed_fields
         if raw_fields.is_a?(Hash)
-          raw_fields.inject({}) { |h,(k,v)| h[k.to_sym] = v.map(&:to_sym); h}
+          raw_fields.inject({}) { |h, (k, v)| h[k.to_sym] = v.map(&:to_sym); h }
         elsif raw_fields.is_a?(Array)
           if root.nil?
-            raise ArgumentError, 'The root argument must be specified if the fileds argument is an array.'
+            raise ArgumentError, 'The root argument must be specified if the fields argument is an array.'
           end
           hash = {}
           hash[root.to_sym] = raw_fields.map(&:to_sym)
@@ -34,7 +35,6 @@ module ActiveModel
           {}
         end
       end
-
     end
   end
-end
+end

data/lib/active_model/serializer/has_many_reflection.rb

@@ -0,0 +1,10 @@
+module ActiveModel
+  class Serializer
+    # @api private
+    class HasManyReflection < CollectionReflection
+      def macro
+        :has_many
+      end
+    end
+  end
+end

data/lib/active_model/serializer/has_one_reflection.rb

@@ -0,0 +1,10 @@
+module ActiveModel
+  class Serializer
+    # @api private
+    class HasOneReflection < SingularReflection
+      def macro
+        :has_one
+      end
+    end
+  end
+end

data/lib/active_model/serializer/lint.rb

@@ -0,0 +1,129 @@
+module ActiveModel::Serializer::Lint
+  # == Active \Model \Serializer \Lint \Tests
+  #
+  # You can test whether an object is compliant with the Active \Model \Serializers
+  # API by including <tt>ActiveModel::Serializer::Lint::Tests</tt> in your TestCase.
+  # It will include tests that tell you whether your object is fully compliant,
+  # or if not, which aspects of the API are not implemented.
+  #
+  # Note an object is not required to implement all APIs in order to work
+  # with Active \Model \Serializers. This module only intends to provide guidance in case
+  # you want all features out of the box.
+  #
+  # These tests do not attempt to determine the semantic correctness of the
+  # returned values. For instance, you could implement <tt>serializable_hash</tt> to
+  # always return +{}+, and the tests would pass. It is up to you to ensure
+  # that the values are semantically meaningful.
+  module Tests
+    # Passes if the object responds to <tt>serializable_hash</tt> and if it takes
+    # zero or one arguments.
+    # Fails otherwise.
+    #
+    # <tt>serializable_hash</tt> returns a hash representation of a object's attributes.
+    # Typically, it is implemented by including ActiveModel::Serialization.
+    def test_serializable_hash
+      assert_respond_to resource, :serializable_hash, 'The resource should respond to serializable_hash'
+      resource.serializable_hash
+      resource.serializable_hash(nil)
+    end
+
+    # Passes if the object responds to <tt>read_attribute_for_serialization</tt>
+    # and if it requires one argument (the attribute to be read).
+    # Fails otherwise.
+    #
+    # <tt>read_attribute_for_serialization</tt> gets the attribute value for serialization
+    # Typically, it is implemented by including ActiveModel::Serialization.
+    def test_read_attribute_for_serialization
+      assert_respond_to resource, :read_attribute_for_serialization, 'The resource should respond to read_attribute_for_serialization'
+      actual_arity = resource.method(:read_attribute_for_serialization).arity
+      if defined?(::Rubinius)
+        #  1 for def read_attribute_for_serialization(name); end
+        # -2 for alias :read_attribute_for_serialization :send for rbx because :shrug:
+        assert_includes [1, -2], actual_arity, "expected #{actual_arity.inspect} to be 1 or -2"
+      else
+        # using absolute value since arity is:
+        #  1 for def read_attribute_for_serialization(name); end
+        # -1 for alias :read_attribute_for_serialization :send
+        assert_includes [1, -1], actual_arity, "expected #{actual_arity.inspect} to be 1 or -1"
+      end
+    end
+
+    # Passes if the object responds to <tt>as_json</tt> and if it takes
+    # zero or one arguments.
+    # Fails otherwise.
+    #
+    # <tt>as_json</tt> returns a hash representation of a serialized object.
+    # It may delegate to <tt>serializable_hash</tt>
+    # Typically, it is implemented either by including ActiveModel::Serialization
+    # which includes ActiveModel::Serializers::JSON.
+    # or by the JSON gem when required.
+    def test_as_json
+      assert_respond_to resource, :as_json
+      resource.as_json
+      resource.as_json(nil)
+    end
+
+    # Passes if the object responds to <tt>to_json</tt> and if it takes
+    # zero or one arguments.
+    # Fails otherwise.
+    #
+    # <tt>to_json</tt> returns a string representation (JSON) of a serialized object.
+    # It may be called on the result of <tt>as_json</tt>.
+    # Typically, it is implemented on all objects when the JSON gem is required.
+    def test_to_json
+      assert_respond_to resource, :to_json
+      resource.to_json
+      resource.to_json(nil)
+    end
+
+    # Passes if the object responds to <tt>cache_key</tt> and if it takes no
+    # arguments (Rails 4.0) or a splat (Rails 4.1+).
+    # Fails otherwise.
+    #
+    # <tt>cache_key</tt> returns a (self-expiring) unique key for the object,
+    # which is used by the adapter.
+    # It is not required unless caching is enabled.
+    def test_cache_key
+      assert_respond_to resource, :cache_key
+      actual_arity = resource.method(:cache_key).arity
+      # using absolute value since arity is:
+      #   0 for Rails 4.1+, *timestamp_names
+      #  -1 for Rails 4.0, no arguments
+      assert_includes [-1, 0], actual_arity, "expected #{actual_arity.inspect} to be 0 or -1"
+    end
+
+    # Passes if the object responds to <tt>id</tt> and if it takes no
+    # arguments.
+    # Fails otherwise.
+    #
+    # <tt>id</tt> returns a unique identifier for the object.
+    # It is not required unless caching is enabled.
+    def test_id
+      assert_respond_to resource, :id
+      assert_equal resource.method(:id).arity, 0
+    end
+
+    # Passes if the object's class responds to <tt>model_name</tt> and if it
+    # is in an instance of +ActiveModel::Name+.
+    # Fails otherwise.
+    #
+    # <tt>model_name</tt> returns an ActiveModel::Name instance.
+    # It is used by the serializer to identify the object's type.
+    # It is not required unless caching is enabled.
+    def test_model_name
+      resource_class = resource.class
+      assert_respond_to resource_class, :model_name
+      assert_instance_of resource_class.model_name, ActiveModel::Name
+    end
+
+    private
+
+    def resource
+      @resource or fail "'@resource' must be set as the linted object"
+    end
+
+    def assert_instance_of(result, name)
+      assert result.instance_of?(name), "#{result} should be an instance of #{name}"
+    end
+  end
+end