cheap_ams 0.10.0.rc2

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

@@ -0,0 +1,183 @@
+require 'active_model/serializer/adapter/json_api/fragment_cache'
+require 'active_model/serializer/adapter/json_api/pagination_links'
+
+module ActiveModel
+  class Serializer
+    class Adapter
+      class JsonApi < Adapter
+        def initialize(serializer, options = {})
+          super
+          @hash = { data: [] }
+
+          if fields = options.delete(:fields)
+            @fieldset = ActiveModel::Serializer::Fieldset.new(fields, serializer.json_key)
+          else
+            @fieldset = options[:fieldset]
+          end
+        end
+
+        def serializable_hash(options = nil)
+          options ||= {}
+          if serializer.respond_to?(:each)
+            serializer.each do |s|
+              result = self.class.new(s, @options.merge(fieldset: @fieldset)).serializable_hash(options)
+              @hash[:data] << result[:data]
+
+              if result[:included]
+                @hash[:included] ||= []
+                @hash[:included] |= result[:included]
+              end
+            end
+
+            add_links(options)
+          else
+            @hash[:data] = attributes_for_serializer(serializer, options)
+            add_resource_relationships(@hash[:data], serializer)
+          end
+          @hash
+        end
+
+        def fragment_cache(cached_hash, non_cached_hash)
+          root = false if @options.include?(:include)
+          JsonApi::FragmentCache.new().fragment_cache(root, cached_hash, non_cached_hash)
+        end
+
+        private
+
+        def add_relationships(resource, name, serializers)
+          resource[:relationships] ||= {}
+          resource[:relationships][name] ||= { data: [] }
+          resource[:relationships][name][:data] += serializers.map { |serializer| { type: serializer.json_api_type, id: serializer.id.to_s } }
+        end
+
+        def add_relationship(resource, name, serializer, val=nil)
+          resource[:relationships] ||= {}
+          resource[:relationships][name] = { data: val }
+
+          if serializer && serializer.object
+            resource[:relationships][name][:data] = { type: serializer.json_api_type, id: serializer.id.to_s }
+          end
+        end
+
+        def add_included(resource_name, serializers, parent = nil)
+          unless serializers.respond_to?(:each)
+            return unless serializers.object
+            serializers = Array(serializers)
+          end
+          resource_path = [parent, resource_name].compact.join('.')
+          if include_assoc?(resource_path)
+            @hash[:included] ||= []
+
+            serializers.each do |serializer|
+              attrs = attributes_for_serializer(serializer, @options)
+
+              add_resource_relationships(attrs, serializer, add_included: false)
+
+              @hash[:included].push(attrs) unless @hash[:included].include?(attrs)
+            end
+          end
+
+          serializers.each do |serializer|
+            serializer.associations.each do |association|
+              serializer = association.serializer
+
+              add_included(association.key, serializer, resource_path) if serializer
+            end if include_nested_assoc? resource_path
+          end
+        end
+
+        def attributes_for_serializer(serializer, options)
+          if serializer.respond_to?(:each)
+            result = []
+            serializer.each do |object|
+              result << resource_object_for(object, options)
+            end
+          else
+            result = resource_object_for(serializer, options)
+          end
+          result
+        end
+
+        def resource_object_for(serializer, options)
+          options[:fields] = @fieldset && @fieldset.fields_for(serializer)
+          options[:required_fields] = [:id, :json_api_type]
+
+          cache_check(serializer) do
+            attributes = serializer.attributes(options)
+
+            result = {
+              id: attributes.delete(:id).to_s,
+              type: attributes.delete(:json_api_type)
+            }
+
+            result[:attributes] = attributes if attributes.any?
+            result
+          end
+        end
+
+        def include_assoc?(assoc)
+          return false unless @options[:include]
+          check_assoc("#{assoc}$")
+        end
+
+        def include_nested_assoc?(assoc)
+          return false unless @options[:include]
+          check_assoc("#{assoc}.")
+        end
+
+        def check_assoc(assoc)
+          include_opt = @options[:include]
+          include_opt = include_opt.split(',') if include_opt.is_a?(String)
+          include_opt.any? do |s|
+            s.match(/^#{assoc.gsub('.', '\.')}/)
+          end
+        end
+
+        def add_resource_relationships(attrs, serializer, options = {})
+          options[:add_included] = options.fetch(:add_included, true)
+
+          serializer.associations.each do |association|
+            key = association.key
+            serializer = association.serializer
+            opts = association.options
+
+            attrs[:relationships] ||= {}
+
+            if serializer.respond_to?(:each)
+              add_relationships(attrs, key, serializer)
+            else
+              if opts[:virtual_value]
+                add_relationship(attrs, key, nil, opts[:virtual_value])
+              else
+                add_relationship(attrs, key, serializer)
+              end
+            end
+
+            if options[:add_included]
+              Array(serializer).each do |s|
+                add_included(key, s)
+              end
+            end
+          end
+        end
+
+        def add_links(options)
+          links = @hash.fetch(:links) { {} }
+          resources = serializer.instance_variable_get(:@resource)
+          @hash[:links] = add_pagination_links(links, resources, options) if is_paginated?(resources)
+        end
+
+        def add_pagination_links(links, resources, options)
+          pagination_links = JsonApi::PaginationLinks.new(resources, options[:context]).serializable_hash(options)
+          links.update(pagination_links)
+        end
+
+        def is_paginated?(resource)
+          resource.respond_to?(:current_page) &&
+            resource.respond_to?(:total_pages) &&
+            resource.respond_to?(:size)
+        end
+      end
+    end
+  end
+end

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

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

data/lib/active_model/serializer/adapter.rb

@@ -0,0 +1,98 @@
+module ActiveModel
+  class Serializer
+    class Adapter
+      extend ActiveSupport::Autoload
+      require 'active_model/serializer/adapter/json'
+      require 'active_model/serializer/adapter/json_api'
+      autoload :FlattenJson
+      autoload :Null
+      autoload :FragmentCache
+
+      def self.create(resource, options = {})
+        override = options.delete(:adapter)
+        klass = override ? adapter_class(override) : ActiveModel::Serializer.adapter
+        klass.new(resource, options)
+      end
+
+      def self.adapter_class(adapter)
+        adapter_name = adapter.to_s.classify.sub("API", "Api")
+        "ActiveModel::Serializer::Adapter::#{adapter_name}".safe_constantize
+      end
+
+      attr_reader :serializer
+
+      def initialize(serializer, options = {})
+        @serializer = serializer
+        @options = options
+      end
+
+      def serializable_hash(options = nil)
+        raise NotImplementedError, 'This is an abstract method. Should be implemented at the concrete adapter.'
+      end
+
+      def as_json(options = nil)
+        hash = serializable_hash(options)
+        include_meta(hash)
+        hash
+      end
+
+      def fragment_cache(*args)
+        raise NotImplementedError, 'This is an abstract method. Should be implemented at the concrete adapter.'
+      end
+
+      private
+
+      def cache_check(serializer)
+        @cached_serializer = serializer
+        @klass             = @cached_serializer.class
+        if is_cached?
+          @klass._cache.fetch(cache_key, @klass._cache_options) do
+            yield
+          end
+        elsif is_fragment_cached?
+          FragmentCache.new(self, @cached_serializer, @options).fetch
+        else
+          yield
+        end
+      end
+
+      def is_cached?
+        @klass._cache && !@klass._cache_only && !@klass._cache_except
+      end
+
+      def is_fragment_cached?
+        @klass._cache_only && !@klass._cache_except || !@klass._cache_only && @klass._cache_except
+      end
+
+      def cache_key
+        parts = []
+        parts << object_cache_key
+        parts << @klass._cache_digest unless @klass._cache_options && @klass._cache_options[:skip_digest]
+        parts.join("/")
+      end
+
+      def object_cache_key
+        object_time_safe = @cached_serializer.object.updated_at
+        object_time_safe = object_time_safe.strftime("%Y%m%d%H%M%S%9N") if object_time_safe.respond_to?(:strftime)
+        (@klass._cache_key) ? "#{@klass._cache_key}/#{@cached_serializer.object.id}-#{object_time_safe}" : @cached_serializer.object.cache_key
+      end
+
+      def meta
+        serializer.meta if serializer.respond_to?(:meta)
+      end
+
+      def meta_key
+        serializer.meta_key || "meta"
+      end
+
+      def root
+        serializer.json_key.to_sym if serializer.json_key
+      end
+
+      def include_meta(json)
+        json[meta_key] = meta if meta
+        json
+      end
+    end
+  end
+end

data/lib/active_model/serializer/array_serializer.rb

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

data/lib/active_model/serializer/association.rb

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,14 @@
+module ActiveModel
+  class Serializer
+    module Configuration
+      include ActiveSupport::Configurable
+      extend ActiveSupport::Concern
+
+      included do |base|
+        base.config.array_serializer = ActiveModel::Serializer::ArraySerializer
+        base.config.adapter = :flatten_json
+        base.config.jsonapi_resource_type = :plural
+      end
+    end
+  end
+end

data/lib/active_model/serializer/fieldset.rb

@@ -0,0 +1,42 @@
+module ActiveModel
+  class Serializer
+    class Fieldset
+
+      def initialize(fields, root = nil)
+        @root       = root
+        @raw_fields = fields
+      end
+
+      def fields
+        @fields ||= parsed_fields
+      end
+
+      def fields_for(serializer)
+        key = serializer.json_key
+        fields[key.to_sym] || fields[key.pluralize.to_sym]
+      end
+
+    private
+
+      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}
+        elsif raw_fields.is_a?(Array)
+          if root.nil?
+            raise ArgumentError, 'The root argument must be specified if the fileds argument is an array.'
+          end
+          hash = {}
+          hash[root.to_sym] = raw_fields.map(&:to_sym)
+          hash
+        else
+          {}
+        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,131 @@
+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

data/lib/active_model/serializer/railtie.rb

@@ -0,0 +1,9 @@
+require 'rails/railtie'
+module ActiveModel
+  class Railtie < Rails::Railtie
+    initializer 'generators' do |app|
+      app.load_generators
+      require 'generators/serializer/resource_override'
+    end
+  end
+end