active_model_serializers 0.10.0.rc3 → 0.10.0.rc4

data/lib/action_controller/serialization.rb

@@ -1,4 +1,5 @@
 require 'active_support/core_ext/class/attribute'
+require 'active_model_serializers/serialization_context'
 
 module ActionController
   module Serialization
@@ -9,6 +10,12 @@ module ActionController
     # Deprecated
     ADAPTER_OPTION_KEYS = ActiveModel::SerializableResource::ADAPTER_OPTION_KEYS
 
+    module ClassMethods
+      def serialization_scope(scope)
+        self._serialization_scope = scope
+      end
+    end
+
     included do
       class_attribute :_serialization_scope
       self._serialization_scope = :current_user
@@ -30,8 +37,11 @@ module ActionController
         serializable_resource.serialization_scope ||= serialization_scope
         serializable_resource.serialization_scope_name = _serialization_scope
         begin
-          serializable_resource.adapter
-        rescue ActiveModel::Serializer::ArraySerializer::NoSerializerError
+          # Necessary to ensure we have an adapter for the serializable resource
+          # after it has been figured.
+          # TODO: This logic should be less opaque and probably moved into the SerializableResource.
+          serializable_resource.tap(&:adapter)
+        rescue ActiveModel::Serializer::CollectionSerializer::NoSerializerError
           resource
         end
       else
@@ -46,16 +56,10 @@ module ActionController
 
     [:_render_option_json, :_render_with_renderer_json].each do |renderer_method|
       define_method renderer_method do |resource, options|
-        options.fetch(:context) { options[:context] = request }
+        options.fetch(:serialization_context) { options[:serialization_context] = ActiveModelSerializers::SerializationContext.new(request) }
         serializable_resource = get_serializer(resource, options)
         super(serializable_resource, options)
       end
     end
-
-    module ClassMethods
-      def serialization_scope(scope)
-        self._serialization_scope = scope
-      end
-    end
   end
 end

data/lib/active_model/serializable_resource.rb

@@ -1,7 +1,13 @@
 require 'set'
 module ActiveModel
   class SerializableResource
-    ADAPTER_OPTION_KEYS = Set.new([:include, :fields, :adapter])
+    ADAPTER_OPTION_KEYS = Set.new([:include, :fields, :adapter, :meta, :meta_key, :links])
+    include ActiveModelSerializers::Logging
+
+    delegate :serializable_hash, :as_json, :to_json, to: :adapter
+    notify :serializable_hash, :render
+    notify :as_json, :render
+    notify :to_json, :render
 
     # Primary interface to composing a resource with a serializer and adapter.
     # @return the serializable_resource, ready for #as_json/#to_json/#serializable_hash.
@@ -11,8 +17,6 @@ module ActiveModel
         options.partition { |k, _| ADAPTER_OPTION_KEYS.include? k }.map { |h| Hash[h] }
     end
 
-    delegate :serializable_hash, :as_json, :to_json, to: :adapter
-
     def serialization_scope=(scope)
       serializer_opts[:scope] = scope
     end
@@ -61,10 +65,8 @@ module ActiveModel
       use_adapter? && !!(serializer)
     end
 
-    private
+    protected
 
-    ActiveModelSerializers.silence_warnings do
-      attr_reader :resource, :adapter_opts, :serializer_opts
-    end
+    attr_reader :resource, :adapter_opts, :serializer_opts
   end
 end

data/lib/active_model/serializer.rb

@@ -1,120 +1,111 @@
 require 'thread_safe'
-
+require 'active_model/serializer/collection_serializer'
+require 'active_model/serializer/array_serializer'
+require 'active_model/serializer/include_tree'
+require 'active_model/serializer/associations'
+require 'active_model/serializer/attributes'
+require 'active_model/serializer/caching'
+require 'active_model/serializer/configuration'
+require 'active_model/serializer/fieldset'
+require 'active_model/serializer/lint'
+require 'active_model/serializer/links'
+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 :Configuration
-    autoload :ArraySerializer
-    autoload :Adapter
-    autoload :Lint
-    autoload :Associations
-    autoload :Fieldset
-    autoload :Utils
     include Configuration
     include Associations
-
-    # Matches
-    #  "c:/git/emberjs/ember-crm-backend/app/serializers/lead_serializer.rb:1:in `<top (required)>'"
-    #  AND
-    #  "/c/git/emberjs/ember-crm-backend/app/serializers/lead_serializer.rb:1:in `<top (required)>'"
-    #  AS
-    #  c/git/emberjs/ember-crm-backend/app/serializers/lead_serializer.rb
-    CALLER_FILE = /
-      \A       # start of string
-      \S+      # one or more non-spaces
-      (?=      # stop previous match when
-        :\d+     # a colon is followed by one or more digits
-        :in      # followed by a colon followed by in
-      )
-    /x
-
-    class << self
-      attr_accessor :_attributes
-      attr_accessor :_attributes_keys
-      attr_accessor :_cache
-      attr_accessor :_fragmented
-      attr_accessor :_cache_key
-      attr_accessor :_cache_only
-      attr_accessor :_cache_except
-      attr_accessor :_cache_options
-      attr_accessor :_cache_digest
+    include Attributes
+    include Caching
+    include Links
+    include Type
+    require 'active_model/serializer/adapter'
+
+    # @param resource [ActiveRecord::Base, ActiveModelSerializers::Model]
+    # @return [ActiveModel::Serializer]
+    #   Preferentially returns
+    #   1. resource.serializer
+    #   2. ArraySerializer when resource is a collection
+    #   3. options[:serializer]
+    #   4. lookup serializer when resource is a Class
+    def self.serializer_for(resource, options = {})
+      if resource.respond_to?(:serializer_class)
+        resource.serializer_class
+      elsif resource.respond_to?(:to_ary)
+        config.collection_serializer
+      else
+        options.fetch(:serializer) { get_serializer_for(resource.class) }
+      end
     end
 
-    def self.inherited(base)
-      base._attributes = self._attributes.try(:dup) || []
-      base._attributes_keys = self._attributes_keys.try(:dup) || {}
-      base._cache_digest = digest_caller_file(caller.first)
-      super
+    # @see ActiveModel::Serializer::Adapter.lookup
+    def self.adapter
+      ActiveModel::Serializer::Adapter.lookup(config.adapter)
     end
 
-    def self.attributes(*attrs)
-      attrs = attrs.first if attrs.first.class == Array
-      @_attributes.concat attrs
-      @_attributes.uniq!
+    # @api private
+    def self.serializer_lookup_chain_for(klass)
+      chain = []
 
-      attrs.each do |attr|
-        define_method attr do
-          object && object.read_attribute_for_serialization(attr)
-        end unless method_defined?(attr) || _fragmented.respond_to?(attr)
-      end
-    end
+      resource_class_name = klass.name.demodulize
+      resource_namespace = klass.name.deconstantize
+      serializer_class_name = "#{resource_class_name}Serializer"
 
-    def self.attribute(attr, options = {})
-      key = options.fetch(:key, attr)
-      @_attributes_keys[attr] = { key: key } if key != attr
-      @_attributes << key unless @_attributes.include?(key)
+      chain.push("#{name}::#{serializer_class_name}") if self != ActiveModel::Serializer
+      chain.push("#{resource_namespace}::#{serializer_class_name}")
 
-      ActiveModelSerializers.silence_warnings do
-        define_method key do
-          object.read_attribute_for_serialization(attr)
-        end unless (key != :id && method_defined?(key)) || _fragmented.respond_to?(attr)
-      end
+      chain
     end
 
-    def self.fragmented(serializer)
-      @_fragmented = serializer
+    # Used to cache serializer name => serializer class
+    # when looked up by Serializer.get_serializer_for.
+    def self.serializers_cache
+      @serializers_cache ||= ThreadSafe::Cache.new
     end
 
-    # Enables a serializer to be automatically cached
-    def self.cache(options = {})
-      @_cache = ActionController::Base.cache_store if Rails.configuration.action_controller.perform_caching
-      @_cache_key = options.delete(:key)
-      @_cache_only = options.delete(:only)
-      @_cache_except = options.delete(:except)
-      @_cache_options = (options.empty?) ? nil : options
-    end
+    # @api private
+    # Find a serializer from a class and caches the lookup.
+    # Preferentially retuns:
+    #   1. class name appended with "Serializer"
+    #   2. try again with superclass, if present
+    #   3. nil
+    def self.get_serializer_for(klass)
+      return nil unless config.serializer_lookup_enabled
+      serializers_cache.fetch_or_store(klass) do
+        # NOTE(beauby): When we drop 1.9.3 support we can lazify the map for perfs.
+        serializer_class = serializer_lookup_chain_for(klass).map(&:safe_constantize).find { |x| x && x < ActiveModel::Serializer }
 
-    def self.serializer_for(resource, options = {})
-      if resource.respond_to?(:serializer_class)
-        resource.serializer_class
-      elsif resource.respond_to?(:to_ary)
-        config.array_serializer
-      else
-        options.fetch(:serializer, get_serializer_for(resource.class))
+        if serializer_class
+          serializer_class
+        elsif klass.superclass
+          get_serializer_for(klass.superclass)
+        end
       end
     end
 
-    # @see ActiveModel::Serializer::Adapter.lookup
-    def self.adapter
-      ActiveModel::Serializer::Adapter.lookup(config.adapter)
+    def self._serializer_instance_method_defined?(name)
+      _serializer_instance_methods.include?(name)
     end
 
-    def self.root_name
-      name.demodulize.underscore.sub(/_serializer$/, '') if name
+    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, :meta, :meta_key, :scope
+    attr_accessor :object, :root, :scope
 
+    # `scope_name` is set as :current_user by default in the controller.
+    # If the instance does not have a method named `scope_name`, it
+    # defines the method so that it calls the +scope+.
     def initialize(object, options = {})
-      @object = object
-      @options = options
-      @root = options[:root]
-      @meta = options[:meta]
-      @meta_key = options[:meta_key]
-      @scope = options[:scope]
-
-      scope_name = options[:scope_name]
+      self.object = object
+      self.instance_options = options
+      self.root = instance_options[:root]
+      self.scope = instance_options[:scope]
+
+      scope_name = instance_options[:scope_name]
       if scope_name && !respond_to?(scope_name)
         self.class.class_eval do
           define_method scope_name, lambda { scope }
@@ -122,50 +113,23 @@ module ActiveModel
       end
     end
 
+    # Used by adapter as resource root.
     def json_key
-      @root || object.class.model_name.to_s.underscore
+      root || object.class.model_name.to_s.underscore
     end
 
-    def attributes(options = {})
-      attributes =
-        if options[:fields]
-          self.class._attributes & options[:fields]
-        else
-          self.class._attributes.dup
-        end
-
-      attributes.each_with_object({}) do |name, hash|
-        unless self.class._fragmented
-          hash[name] = send(name)
-        else
-          hash[name] = self.class._fragmented.public_send(name)
-        end
+    def read_attribute_for_serialization(attr)
+      if self.class._serializer_instance_method_defined?(attr)
+        send(attr)
+      elsif self.class._fragmented
+        self.class._fragmented.read_attribute_for_serialization(attr)
+      else
+        object.read_attribute_for_serialization(attr)
       end
     end
 
-    def self.serializers_cache
-      @serializers_cache ||= ThreadSafe::Cache.new
-    end
-
-    def self.digest_caller_file(caller_line)
-      serializer_file_path = caller_line[CALLER_FILE]
-      serializer_file_contents = IO.read(serializer_file_path)
-      Digest::MD5.hexdigest(serializer_file_contents)
-    end
-
-    attr_reader :options
+    protected
 
-    def self.get_serializer_for(klass)
-      serializers_cache.fetch_or_store(klass) do
-        serializer_class_name = "#{klass.name}Serializer"
-        serializer_class = serializer_class_name.safe_constantize
-
-        if serializer_class
-          serializer_class
-        elsif klass.superclass
-          get_serializer_for(klass.superclass)
-        end
-      end
-    end
+    attr_accessor :instance_options
   end
 end

data/lib/active_model/serializer/adapter.rb

@@ -1,30 +1,30 @@
 module ActiveModel
   class Serializer
-    class Adapter
+    module Adapter
       UnknownAdapterError = Class.new(ArgumentError)
       ADAPTER_MAP = {}
       private_constant :ADAPTER_MAP if defined?(private_constant)
-      extend ActiveSupport::Autoload
-      autoload :FragmentCache
-      autoload :Json
-      autoload :JsonApi
-      autoload :Null
-      autoload :FlattenJson
+      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 self.create(resource, options = {})
-        override = options.delete(:adapter)
-        klass = override ? adapter_class(override) : ActiveModel::Serializer.adapter
-        klass.new(resource, options)
-      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 self.adapter_class(adapter)
-        ActiveModel::Serializer::Adapter.lookup(adapter)
-      end
+        # @see ActiveModel::Serializer::Adapter.lookup
+        def adapter_class(adapter)
+          ActiveModel::Serializer::Adapter.lookup(adapter)
+        end
 
-      # Only the Adapter class has these methods.
-      # None of the sublasses have them.
-      class << ActiveModel::Serializer::Adapter
         # @return Hash<adapter_name, adapter_class>
         def adapter_map
           ADAPTER_MAP
@@ -37,12 +37,16 @@ module ActiveModel
 
         # Adds an adapter 'klass' with 'name' to the 'adapter_map'
         # Names are stringified and underscored
-        # @param [Symbol, String] name of the registered adapter
-        # @param [Class] klass - adapter class itself
+        # @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)
-        def register(name, klass)
-          adapter_map.update(name.to_s.underscore => klass)
+        # @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
 
@@ -54,12 +58,12 @@ module ActiveModel
           return adapter if adapter.is_a?(Class)
           adapter_name = adapter.to_s.underscore
           # 2. return if registered
-          adapter_map.fetch(adapter_name) {
+          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}"
@@ -69,91 +73,19 @@ module ActiveModel
         # @api private
         def find_by_name(adapter_name)
           adapter_name = adapter_name.to_s.classify.tr('API', 'Api')
-          ActiveModel::Serializer::Adapter.const_get(adapter_name.to_sym) or # rubocop:disable Style/AndOr
+          "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
 
-      # Automatically register adapters when subclassing
-      def self.inherited(subclass)
-        ActiveModel::Serializer::Adapter.register(subclass.to_s.demodulize, subclass)
-      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
+      # 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