active_model_serializers 0.8.3 → 0.10.0.rc4

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

@@ -0,0 +1,58 @@
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi < Base
+        class 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) || request_url
+          end
+
+          def request_url
+            @request_url ||= context.request_url
+          end
+
+          def query_parameters
+            @query_parameters ||= context.query_parameters
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,223 @@
+module ActiveModel
+  class Serializer
+    module Adapter
+      class JsonApi < Base
+        extend ActiveSupport::Autoload
+        autoload :PaginationLinks
+        autoload :FragmentCache
+        autoload :Link
+        autoload :Deserialization
+
+        # TODO: if we like this abstraction and other API objects to it,
+        # then extract to its own file and require it.
+        module ApiObjects
+          module JsonApi
+            ActiveModelSerializers.config.jsonapi_version = '1.0'
+            ActiveModelSerializers.config.jsonapi_toplevel_meta = {}
+            # Make JSON API top-level jsonapi member opt-in
+            # ref: http://jsonapi.org/format/#document-top-level
+            ActiveModelSerializers.config.jsonapi_include_toplevel_object = false
+
+            module_function
+
+            def add!(hash)
+              hash.merge!(object) if include_object?
+            end
+
+            def include_object?
+              ActiveModelSerializers.config.jsonapi_include_toplevel_object
+            end
+
+            # TODO: see if we can cache this
+            def object
+              object = {
+                jsonapi: {
+                  version: ActiveModelSerializers.config.jsonapi_version,
+                  meta: ActiveModelSerializers.config.jsonapi_toplevel_meta
+                }
+              }
+              object[:jsonapi].reject! { |_, v| v.blank? }
+
+              object
+            end
+          end
+        end
+
+        def initialize(serializer, options = {})
+          super
+          @include_tree = IncludeTree.from_include_args(options[:include])
+          @fieldset = options[:fieldset] || ActiveModel::Serializer::Fieldset.new(options.delete(:fields))
+        end
+
+        def serializable_hash(options = nil)
+          options ||= {}
+
+          hash =
+            if serializer.respond_to?(:each)
+              serializable_hash_for_collection(options)
+            else
+              serializable_hash_for_single_resource
+            end
+
+          ApiObjects::JsonApi.add!(hash)
+
+          if instance_options[:links]
+            hash[:links] ||= {}
+            hash[:links].update(instance_options[:links])
+          end
+
+          hash
+        end
+
+        def fragment_cache(cached_hash, non_cached_hash)
+          root = false if instance_options.include?(:include)
+          ActiveModel::Serializer::Adapter::JsonApi::FragmentCache.new.fragment_cache(root, cached_hash, non_cached_hash)
+        end
+
+        protected
+
+        attr_reader :fieldset
+
+        private
+
+        def serializable_hash_for_collection(options)
+          hash = { data: [] }
+          included = []
+          serializer.each do |s|
+            result = self.class.new(s, instance_options.merge(fieldset: fieldset)).serializable_hash(options)
+            hash[:data] << result[:data]
+            next unless result[:included]
+
+            included |= result[:included]
+          end
+
+          included.delete_if { |resource| hash[:data].include?(resource) }
+          hash[:included] = included if included.any?
+
+          if serializer.paginated?
+            hash[:links] ||= {}
+            hash[:links].update(pagination_links_for(serializer, options))
+          end
+
+          hash
+        end
+
+        def serializable_hash_for_single_resource
+          primary_data = resource_object_for(serializer)
+
+          hash = { data: primary_data }
+
+          included = included_resources(@include_tree, [primary_data])
+          hash[:included] = included if included.any?
+
+          hash
+        end
+
+        def resource_identifier_type_for(serializer)
+          return serializer._type if serializer._type
+          if ActiveModelSerializers.config.jsonapi_resource_type == :singular
+            serializer.object.class.model_name.singular
+          else
+            serializer.object.class.model_name.plural
+          end
+        end
+
+        def resource_identifier_id_for(serializer)
+          if serializer.respond_to?(:id)
+            serializer.id
+          else
+            serializer.object.id
+          end
+        end
+
+        def resource_identifier_for(serializer)
+          type = resource_identifier_type_for(serializer)
+          id   = resource_identifier_id_for(serializer)
+
+          { id: id.to_s, type: type }
+        end
+
+        def attributes_for(serializer, fields)
+          serializer.attributes(fields).except(:id)
+        end
+
+        def resource_object_for(serializer)
+          resource_object = cache_check(serializer) do
+            resource_object = resource_identifier_for(serializer)
+
+            requested_fields = fieldset && fieldset.fields_for(resource_object[:type])
+            attributes = attributes_for(serializer, requested_fields)
+            resource_object[:attributes] = attributes if attributes.any?
+            resource_object
+          end
+
+          relationships = relationships_for(serializer)
+          resource_object[:relationships] = relationships if relationships.any?
+
+          links = links_for(serializer)
+          resource_object[:links] = links if links.any?
+
+          resource_object
+        end
+
+        def relationship_value_for(serializer, options = {})
+          if serializer.respond_to?(:each)
+            serializer.map { |s| resource_identifier_for(s) }
+          else
+            if options[:virtual_value]
+              options[:virtual_value]
+            elsif serializer && serializer.object
+              resource_identifier_for(serializer)
+            end
+          end
+        end
+
+        def relationships_for(serializer)
+          resource_type = resource_identifier_type_for(serializer)
+          requested_associations = fieldset.fields_for(resource_type) || '*'
+          include_tree = IncludeTree.from_include_args(requested_associations)
+          serializer.associations(include_tree).each_with_object({}) do |association, hash|
+            hash[association.key] = { data: relationship_value_for(association.serializer, association.options) }
+          end
+        end
+
+        def included_resources(include_tree, primary_data)
+          included = []
+
+          serializer.associations(include_tree).each do |association|
+            add_included_resources_for(association.serializer, include_tree[association.key], primary_data, included)
+          end
+
+          included
+        end
+
+        def add_included_resources_for(serializer, include_tree, primary_data, included)
+          if serializer.respond_to?(:each)
+            serializer.each { |s| add_included_resources_for(s, include_tree, primary_data, included) }
+          else
+            return unless serializer && serializer.object
+
+            resource_object = resource_object_for(serializer)
+
+            return if included.include?(resource_object) || primary_data.include?(resource_object)
+            included.push(resource_object)
+
+            serializer.associations(include_tree).each do |association|
+              add_included_resources_for(association.serializer, include_tree[association.key], primary_data, included)
+            end
+          end
+        end
+
+        def links_for(serializer)
+          serializer._links.each_with_object({}) do |(name, value), hash|
+            hash[name] = Link.new(serializer, value).as_json
+          end
+        end
+
+        def pagination_links_for(serializer, options)
+          JsonApi::PaginationLinks.new(serializer.object, options[:serialization_context]).serializable_hash(options)
+        end
+      end
+    end
+  end
+end

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

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

data/lib/active_model/serializer/adapter.rb

@@ -0,0 +1,91 @@
+module ActiveModel
+  class Serializer
+    module Adapter
+      UnknownAdapterError = Class.new(ArgumentError)
+      ADAPTER_MAP = {}
+      private_constant :ADAPTER_MAP if defined?(private_constant)
+      require 'active_model/serializer/adapter/fragment_cache'
+      require 'active_model/serializer/adapter/cached_serializer'
+
+      class << self # All methods are class functions
+        def new(*args)
+          fail ArgumentError, 'Adapters inherit from Adapter::Base.' \
+            "Adapter.new called with args: '#{args.inspect}', from" \
+            "'caller[0]'."
+        end
+
+        def create(resource, options = {})
+          override = options.delete(:adapter)
+          klass = override ? adapter_class(override) : ActiveModel::Serializer.adapter
+          klass.new(resource, options)
+        end
+
+        # @see ActiveModel::Serializer::Adapter.lookup
+        def adapter_class(adapter)
+          ActiveModel::Serializer::Adapter.lookup(adapter)
+        end
+
+        # @return Hash<adapter_name, adapter_class>
+        def adapter_map
+          ADAPTER_MAP
+        end
+
+        # @return [Array<Symbol>] list of adapter names
+        def adapters
+          adapter_map.keys.sort
+        end
+
+        # Adds an adapter 'klass' with 'name' to the 'adapter_map'
+        # Names are stringified and underscored
+        # @param name [Symbol, String, Class] name of the registered adapter
+        # @param klass [Class] adapter class itself, optional if name is the class
+        # @example
+        #     AMS::Adapter.register(:my_adapter, MyAdapter)
+        # @note The registered name strips out 'ActiveModel::Serializer::Adapter::'
+        #   so that registering 'ActiveModel::Serializer::Adapter::Json' and
+        #   'Json' will both register as 'json'.
+        def register(name, klass = name)
+          name = name.to_s.gsub(/\AActiveModel::Serializer::Adapter::/, ''.freeze)
+          adapter_map.update(name.underscore => klass)
+          self
+        end
+
+        # @param  adapter [String, Symbol, Class] name to fetch adapter by
+        # @return [ActiveModel::Serializer::Adapter] subclass of Adapter
+        # @raise  [UnknownAdapterError]
+        def lookup(adapter)
+          # 1. return if is a class
+          return adapter if adapter.is_a?(Class)
+          adapter_name = adapter.to_s.underscore
+          # 2. return if registered
+          adapter_map.fetch(adapter_name) do
+            # 3. try to find adapter class from environment
+            adapter_class = find_by_name(adapter_name)
+            register(adapter_name, adapter_class)
+            adapter_class
+          end
+        rescue NameError, ArgumentError => e
+          failure_message =
+            "NameError: #{e.message}. Unknown adapter: #{adapter.inspect}. Valid adapters are: #{adapters}"
+          raise UnknownAdapterError, failure_message, e.backtrace
+        end
+
+        # @api private
+        def find_by_name(adapter_name)
+          adapter_name = adapter_name.to_s.classify.tr('API', 'Api')
+          "ActiveModel::Serializer::Adapter::#{adapter_name}".safe_constantize ||
+            "ActiveModel::Serializer::Adapter::#{adapter_name.pluralize}".safe_constantize or # rubocop:disable Style/AndOr
+            fail UnknownAdapterError
+        end
+        private :find_by_name
+      end
+
+      # Gotta be at the bottom to use the code above it :(
+      require 'active_model/serializer/adapter/base'
+      require 'active_model/serializer/adapter/null'
+      require 'active_model/serializer/adapter/attributes'
+      require 'active_model/serializer/adapter/json'
+      require 'active_model/serializer/adapter/json_api'
+    end
+  end
+end

data/lib/active_model/serializer/array_serializer.rb

@@ -0,0 +1,9 @@
+require 'active_model/serializer/collection_serializer'
+class ActiveModel::Serializer
+  class ArraySerializer < CollectionSerializer
+    def initialize(*)
+      warn "Calling deprecated ArraySerializer in #{caller[0..2].join(', ')}. Please use CollectionSerializer"
+      super
+    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