active_model_serializers 0.10.0.rc4 → 0.10.0.rc5

data/lib/active_model/serializer.rb

@@ -1,6 +1,8 @@
 require 'thread_safe'
 require 'active_model/serializer/collection_serializer'
 require 'active_model/serializer/array_serializer'
+require 'active_model/serializer/error_serializer'
+require 'active_model/serializer/errors_serializer'
 require 'active_model/serializer/include_tree'
 require 'active_model/serializer/associations'
 require 'active_model/serializer/attributes'
@@ -9,19 +11,23 @@ require 'active_model/serializer/configuration'
 require 'active_model/serializer/fieldset'
 require 'active_model/serializer/lint'
 require 'active_model/serializer/links'
+require 'active_model/serializer/meta'
 require 'active_model/serializer/type'
 
 # ActiveModel::Serializer is an abstract class that is
 # reified when subclassed to decorate a resource.
 module ActiveModel
   class Serializer
+    extend ActiveSupport::Autoload
+    autoload :Adapter
+    autoload :Null
     include Configuration
     include Associations
     include Attributes
     include Caching
     include Links
+    include Meta
     include Type
-    require 'active_model/serializer/adapter'
 
     # @param resource [ActiveRecord::Base, ActiveModelSerializers::Model]
     # @return [ActiveModel::Serializer]
@@ -40,9 +46,14 @@ module ActiveModel
       end
     end
 
-    # @see ActiveModel::Serializer::Adapter.lookup
+    # @see ActiveModelSerializers::Adapter.lookup
+    # Deprecated
     def self.adapter
-      ActiveModel::Serializer::Adapter.lookup(config.adapter)
+      ActiveModelSerializers::Adapter.lookup(config.adapter)
+    end
+    class << self
+      extend ActiveModelSerializers::Deprecate
+      deprecate :adapter, 'ActiveModelSerializers::Adapter.configured_adapter'
     end
 
     # @api private
@@ -67,7 +78,7 @@ module ActiveModel
 
     # @api private
     # Find a serializer from a class and caches the lookup.
-    # Preferentially retuns:
+    # Preferentially returns:
     #   1. class name appended with "Serializer"
     #   2. try again with superclass, if present
     #   3. nil
@@ -85,15 +96,6 @@ module ActiveModel
       end
     end
 
-    def self._serializer_instance_method_defined?(name)
-      _serializer_instance_methods.include?(name)
-    end
-
-    def self._serializer_instance_methods
-      @_serializer_instance_methods ||= (public_instance_methods - Object.public_instance_methods).to_set
-    end
-    private_class_method :_serializer_instance_methods
-
     attr_accessor :object, :root, :scope
 
     # `scope_name` is set as :current_user by default in the controller.
@@ -107,19 +109,72 @@ module ActiveModel
 
       scope_name = instance_options[:scope_name]
       if scope_name && !respond_to?(scope_name)
-        self.class.class_eval do
-          define_method scope_name, lambda { scope }
-        end
+        define_singleton_method scope_name, lambda { scope }
       end
     end
 
+    def success?
+      true
+    end
+
+    # @return [Hash] containing the attributes and first level
+    # associations, similar to how ActiveModel::Serializers::JSON is used
+    # in ActiveRecord::Base.
+    #
+    # TODO: Move to here the Attributes adapter logic for
+    # +serializable_hash_for_single_resource(options)+
+    # and include <tt>ActiveModel::Serializers::JSON</tt>.
+    # So that the below is true:
+    #   @param options [nil, Hash] The same valid options passed to `serializable_hash`
+    #      (:only, :except, :methods, and :include).
+    #
+    #     See
+    #     https://github.com/rails/rails/blob/v5.0.0.beta2/activemodel/lib/active_model/serializers/json.rb#L17-L101
+    #     https://github.com/rails/rails/blob/v5.0.0.beta2/activemodel/lib/active_model/serialization.rb#L85-L123
+    #     https://github.com/rails/rails/blob/v5.0.0.beta2/activerecord/lib/active_record/serialization.rb#L11-L17
+    #     https://github.com/rails/rails/blob/v5.0.0.beta2/activesupport/lib/active_support/core_ext/object/json.rb#L147-L162
+    #
+    #   @example
+    #     # The :only and :except options can be used to limit the attributes included, and work
+    #     # similar to the attributes method.
+    #     serializer.as_json(only: [:id, :name])
+    #     serializer.as_json(except: [:id, :created_at, :age])
+    #
+    #     # To include the result of some method calls on the model use :methods:
+    #     serializer.as_json(methods: :permalink)
+    #
+    #     # To include associations use :include:
+    #     serializer.as_json(include: :posts)
+    #     # Second level and higher order associations work as well:
+    #     serializer.as_json(include: { posts: { include: { comments: { only: :body } }, only: :title } })
+    def serializable_hash(adapter_opts = nil)
+      adapter_opts ||= {}
+      adapter_opts = { include: '*', adapter: :attributes }.merge!(adapter_opts)
+      adapter = ActiveModelSerializers::Adapter.create(self, adapter_opts)
+      adapter.serializable_hash(adapter_opts)
+    end
+    alias to_hash serializable_hash
+    alias to_h serializable_hash
+
+    # @see #serializable_hash
+    # TODO: When moving attributes adapter logic here, @see #serializable_hash
+    # So that the below is true:
+    #   @param options [nil, Hash] The same valid options passed to `as_json`
+    #      (:root, :only, :except, :methods, and :include).
+    #   The default for `root` is nil.
+    #   The default value for include_root is false. You can change it to true if the given
+    #   JSON string includes a single root node.
+    def as_json(adapter_opts = nil)
+      serializable_hash(adapter_opts)
+    end
+
     # Used by adapter as resource root.
     def json_key
-      root || object.class.model_name.to_s.underscore
+      root || _type || object.class.model_name.to_s.underscore
     end
 
     def read_attribute_for_serialization(attr)
-      if self.class._serializer_instance_method_defined?(attr)
+      if respond_to?(attr)
         send(attr)
       elsif self.class._fragmented
         self.class._fragmented.read_attribute_for_serialization(attr)

data/lib/active_model/serializer/adapter.rb

@@ -1,91 +1,24 @@
+require 'active_model_serializers/adapter'
+require 'active_model_serializers/deprecate'
+
 module ActiveModel
   class Serializer
+    # @deprecated Use ActiveModelSerializers::Adapter instead
     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
+      class << self
+        extend ActiveModelSerializers::Deprecate
 
-        # @return [Array<Symbol>] list of adapter names
-        def adapters
-          adapter_map.keys.sort
+        DEPRECATED_METHODS = [:create, :adapter_class, :adapter_map, :adapters, :register, :lookup].freeze
+        DEPRECATED_METHODS.each do |method|
+          delegate_and_deprecate method, ActiveModelSerializers::Adapter
         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
+
+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'

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

@@ -1,64 +1,13 @@
 module ActiveModel
   class Serializer
     module Adapter
-      class Attributes < Base
+      class Attributes < DelegateClass(ActiveModelSerializers::Adapter::Attributes)
         def initialize(serializer, options = {})
-          super
-          @include_tree = IncludeTree.from_include_args(options[:include] || '*')
+          super(ActiveModelSerializers::Adapter::Attributes.new(serializer, options))
         end
-
-        def serializable_hash(options = nil)
-          options ||= {}
-
-          if serializer.respond_to?(:each)
-            serializable_hash_for_collection(options)
-          else
-            serializable_hash_for_single_resource(options)
-          end
-        end
-
-        def fragment_cache(cached_hash, non_cached_hash)
-          Json::FragmentCache.new.fragment_cache(cached_hash, non_cached_hash)
-        end
-
-        private
-
-        def serializable_hash_for_collection(options)
-          serializer.map { |s| Attributes.new(s, instance_options).serializable_hash(options) }
-        end
-
-        def serializable_hash_for_single_resource(options)
-          resource = resource_object_for(options)
-          relationships = resource_relationships(options)
-          resource.merge!(relationships)
-        end
-
-        def resource_relationships(options)
-          relationships = {}
-          serializer.associations(@include_tree).each do |association|
-            relationships[association.key] = relationship_value_for(association, options)
-          end
-
-          relationships
-        end
-
-        def relationship_value_for(association, options)
-          return association.options[:virtual_value] if association.options[:virtual_value]
-          return unless association.serializer && association.serializer.object
-
-          opts = instance_options.merge(include: @include_tree[association.key])
-          Attributes.new(association.serializer, opts).serializable_hash(options)
-        end
-
-        # no-op: Attributes adapter does not include meta data, because it does not support root.
-        def include_meta(json)
-          json
-        end
-
-        def resource_object_for(options)
-          cache_check(serializer) do
-            serializer.attributes(options[:fields])
-          end
+        class << self
+          extend ActiveModelSerializers::Deprecate
+          deprecate :new, 'ActiveModelSerializers::Adapter::Json.'
         end
       end
     end

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

@@ -1,56 +1,14 @@
 module ActiveModel
   class Serializer
     module Adapter
-      class Base
-        # Automatically register adapters when subclassing
-        def self.inherited(subclass)
-          ActiveModel::Serializer::Adapter.register(subclass)
+      class Base < DelegateClass(ActiveModelSerializers::Adapter::Base)
+        class << self
+          extend ActiveModelSerializers::Deprecate
+          deprecate :inherited, 'ActiveModelSerializers::Adapter::Base.'
         end
 
-        attr_reader :serializer, :instance_options
-
         def initialize(serializer, options = {})
-          @serializer = serializer
-          @instance_options = options
-        end
-
-        def serializable_hash(_options = nil)
-          fail 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)
-          fail NotImplementedError, 'This is an abstract method. Should be implemented at the concrete adapter.'
-        end
-
-        def cache_check(serializer)
-          CachedSerializer.new(serializer).cache_check(self) do
-            yield
-          end
-        end
-
-        private
-
-        def meta
-          instance_options.fetch(:meta, nil)
-        end
-
-        def meta_key
-          instance_options.fetch(:meta_key, 'meta'.freeze)
-        end
-
-        def root
-          serializer.json_key.to_sym if serializer.json_key
-        end
-
-        def include_meta(json)
-          json[meta_key] = meta if meta
-          json
+          super(ActiveModelSerializers::Adapter::Base.new(serializer, options))
         end
       end
     end

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

@@ -1,19 +1,13 @@
 module ActiveModel
   class Serializer
     module Adapter
-      class Json < Base
-        extend ActiveSupport::Autoload
-        autoload :FragmentCache
-
-        def serializable_hash(options = nil)
-          options ||= {}
-          { root => Attributes.new(serializer, instance_options).serializable_hash(options) }
+      class Json < DelegateClass(ActiveModelSerializers::Adapter::Json)
+        def initialize(serializer, options = {})
+          super(ActiveModelSerializers::Adapter::Json.new(serializer, options))
         end
-
-        private
-
-        def fragment_cache(cached_hash, non_cached_hash)
-          ActiveModel::Serializer::Adapter::Json::FragmentCache.new.fragment_cache(cached_hash, non_cached_hash)
+        class << self
+          extend ActiveModelSerializers::Deprecate
+          deprecate :new, 'ActiveModelSerializers::Adapter::Json.new'
         end
       end
     end

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

@@ -1,221 +1,13 @@
 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
-
+      class JsonApi < DelegateClass(ActiveModelSerializers::Adapter::JsonApi)
         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
+          super(ActiveModelSerializers::Adapter::JsonApi.new(serializer, options))
         end
-
-        def pagination_links_for(serializer, options)
-          JsonApi::PaginationLinks.new(serializer.object, options[:serialization_context]).serializable_hash(options)
+        class << self
+          extend ActiveModelSerializers::Deprecate
+          deprecate :new, 'ActiveModelSerializers::Adapter::JsonApi.new'
         end
       end
     end