active_model_serializers 0.10.0 → 0.10.9

data/lib/active_model_serializers/deprecate.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ##
 # Provides a single method +deprecate+ to be used to declare when
 # something is going away.
@@ -36,8 +38,7 @@ module ActiveModelSerializers
           target = is_a?(Module) ? "#{self}." : "#{self.class}#"
           msg = ["NOTE: #{target}#{name} is deprecated",
                  replacement == :none ? ' with no replacement' : "; use #{replacement} instead",
-                 "\n#{target}#{name} called from #{ActiveModelSerializers.location_of_caller.join(":")}"
-                ]
+                 "\n#{target}#{name} called from #{ActiveModelSerializers.location_of_caller.join(':')}"]
           warn "#{msg.join}."
           send old, *args, &block
         end

data/lib/active_model_serializers/deserialization.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModelSerializers
   module Deserialization
     module_function
@@ -6,8 +8,10 @@ module ActiveModelSerializers
       Adapter::JsonApi::Deserialization.parse(*args)
     end
 
+    # :nocov:
     def jsonapi_parse!(*args)
       Adapter::JsonApi::Deserialization.parse!(*args)
     end
+    # :nocov:
   end
 end

data/lib/active_model_serializers/json_pointer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModelSerializers
   module JsonPointer
     module_function

data/lib/active_model_serializers/logging.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ##
 # ActiveModelSerializers::Logging
 #

data/lib/active_model_serializers/lookup_chain.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module ActiveModelSerializers
+  module LookupChain
+    # Standard appending of Serializer to the resource name.
+    #
+    # Example:
+    #   Author => AuthorSerializer
+    BY_RESOURCE = lambda do |resource_class, _serializer_class, _namespace|
+      serializer_from(resource_class)
+    end
+
+    # Uses the namespace of the resource to find the serializer
+    #
+    # Example:
+    #  British::Author => British::AuthorSerializer
+    BY_RESOURCE_NAMESPACE = lambda do |resource_class, _serializer_class, _namespace|
+      resource_namespace = namespace_for(resource_class)
+      serializer_name = serializer_from(resource_class)
+
+      "#{resource_namespace}::#{serializer_name}"
+    end
+
+    # Uses the controller namespace of the resource to find the serializer
+    #
+    # Example:
+    #  Api::V3::AuthorsController => Api::V3::AuthorSerializer
+    BY_NAMESPACE = lambda do |resource_class, _serializer_class, namespace|
+      resource_name = resource_class_name(resource_class)
+      namespace ? "#{namespace}::#{resource_name}Serializer" : nil
+    end
+
+    # Allows for serializers to be defined in parent serializers
+    # - useful if a relationship only needs a different set of attributes
+    #   than if it were rendered independently.
+    #
+    # Example:
+    #   class BlogSerializer < ActiveModel::Serializer
+    #     class AuthorSerialier < ActiveModel::Serializer
+    #     ...
+    #     end
+    #
+    #     belongs_to :author
+    #     ...
+    #   end
+    #
+    #  The belongs_to relationship would be rendered with
+    #    BlogSerializer::AuthorSerialier
+    BY_PARENT_SERIALIZER = lambda do |resource_class, serializer_class, _namespace|
+      return if serializer_class == ActiveModel::Serializer
+
+      serializer_name = serializer_from(resource_class)
+      "#{serializer_class}::#{serializer_name}"
+    end
+
+    DEFAULT = [
+      BY_PARENT_SERIALIZER,
+      BY_NAMESPACE,
+      BY_RESOURCE_NAMESPACE,
+      BY_RESOURCE
+    ].freeze
+
+    module_function
+
+    def namespace_for(klass)
+      klass.name.deconstantize
+    end
+
+    def resource_class_name(klass)
+      klass.name.demodulize
+    end
+
+    def serializer_from_resource_name(name)
+      "#{name}Serializer"
+    end
+
+    def serializer_from(klass)
+      name = resource_class_name(klass)
+      serializer_from_resource_name(name)
+    end
+  end
+end

data/lib/active_model_serializers/model.rb

@@ -1,49 +1,132 @@
-# ActiveModelSerializers::Model is a convenient
-# serializable class to inherit from when making
-# serializable non-activerecord objects.
+# frozen_string_literal: true
+
+# ActiveModelSerializers::Model is a convenient superclass for making your models
+# from Plain-Old Ruby Objects (PORO). It also serves as a reference implementation
+# that satisfies ActiveModel::Serializer::Lint::Tests.
+require 'active_support/core_ext/hash'
 module ActiveModelSerializers
   class Model
-    include ActiveModel::Model
     include ActiveModel::Serializers::JSON
+    include ActiveModel::Model
 
-    attr_reader :attributes, :errors
+    # Declare names of attributes to be included in +attributes+ hash.
+    # Is only available as a class-method since the ActiveModel::Serialization mixin in Rails
+    # uses an +attribute_names+ local variable, which may conflict if we were to add instance methods here.
+    #
+    # @overload attribute_names
+    #   @return [Array<Symbol>]
+    class_attribute :attribute_names, instance_writer: false, instance_reader: false
+    # Initialize +attribute_names+ for all subclasses.  The array is usually
+    # mutated in the +attributes+ method, but can be set directly, as well.
+    self.attribute_names = []
 
-    def initialize(attributes = {})
-      @attributes = attributes
-      @errors = ActiveModel::Errors.new(self)
-      super
+    # Easily declare instance attributes with setters and getters for each.
+    #
+    # To initialize an instance, all attributes must have setters.
+    # However, the hash returned by +attributes+ instance method will ALWAYS
+    # be the value of the initial attributes, regardless of what accessors are defined.
+    # The only way to change the change the attributes after initialization is
+    # to mutate the +attributes+ directly.
+    # Accessor methods do NOT mutate the attributes.  (This is a bug).
+    #
+    # @note For now, the Model only supports the notion of 'attributes'.
+    #   In the tests, there is a special Model that also supports 'associations'. This is
+    #   important so that we can add accessors for values that should not appear in the
+    #   attributes hash when modeling associations. It is not yet clear if it
+    #   makes sense for a PORO to have associations outside of the tests.
+    #
+    # @overload attributes(names)
+    #   @param names [Array<String, Symbol>]
+    #   @param name [String, Symbol]
+    def self.attributes(*names)
+      self.attribute_names |= names.map(&:to_sym)
+      # Silence redefinition of methods warnings
+      ActiveModelSerializers.silence_warnings do
+        attr_accessor(*names)
+      end
     end
 
-    # Defaults to the downcased model name.
-    def id
-      attributes.fetch(:id) { self.class.name.downcase }
+    # Opt-in to breaking change
+    def self.derive_attributes_from_names_and_fix_accessors
+      unless included_modules.include?(DeriveAttributesFromNamesAndFixAccessors)
+        prepend(DeriveAttributesFromNamesAndFixAccessors)
+      end
     end
 
-    # Defaults to the downcased model name and updated_at
-    def cache_key
-      attributes.fetch(:cache_key) { "#{self.class.name.downcase}/#{id}-#{updated_at.strftime("%Y%m%d%H%M%S%9N")}" }
+    module DeriveAttributesFromNamesAndFixAccessors
+      def self.included(base)
+        # NOTE that +id+ will always be in +attributes+.
+        base.attributes :id
+      end
+
+      # Override the +attributes+ method so that the hash is derived from +attribute_names+.
+      #
+      # The fields in +attribute_names+ determines the returned hash.
+      # +attributes+ are returned frozen to prevent any expectations that mutation affects
+      # the actual values in the model.
+      def attributes
+        self.class.attribute_names.each_with_object({}) do |attribute_name, result|
+          result[attribute_name] = public_send(attribute_name).freeze
+        end.with_indifferent_access.freeze
+      end
     end
 
-    # Defaults to the time the serializer file was modified.
-    def updated_at
-      attributes.fetch(:updated_at) { File.mtime(__FILE__) }
+    # Support for validation and other ActiveModel::Errors
+    # @return [ActiveModel::Errors]
+    attr_reader :errors
+
+    # (see #updated_at)
+    attr_writer :updated_at
+
+    # The only way to change the attributes of an instance is to directly mutate the attributes.
+    # @example
+    #
+    #   model.attributes[:foo] = :bar
+    # @return [Hash]
+    attr_reader :attributes
+
+    # @param attributes [Hash]
+    def initialize(attributes = {})
+      attributes ||= {} # protect against nil
+      @attributes = attributes.symbolize_keys.with_indifferent_access
+      @errors = ActiveModel::Errors.new(self)
+      super
     end
 
-    def read_attribute_for_serialization(key)
-      if key == :id || key == 'id'
-        attributes.fetch(key) { id }
-      else
-        attributes[key]
+    # Defaults to the downcased model name.
+    # This probably isn't a good default, since it's not a unique instance identifier,
+    # but that's what is currently implemented \_('-')_/.
+    #
+    # @note Though +id+ is defined, it will only show up
+    #   in +attributes+ when it is passed in to the initializer or added to +attributes+,
+    #   such as <tt>attributes[:id] = 5</tt>.
+    # @return [String, Numeric, Symbol]
+    def id
+      attributes.fetch(:id) do
+        defined?(@id) ? @id : self.class.model_name.name && self.class.model_name.name.downcase
       end
     end
 
-    # The following methods are needed to be minimally implemented for ActiveModel::Errors
-    def self.human_attribute_name(attr, _options = {})
-      attr
+    # When not set, defaults to the time the file was modified.
+    #
+    # @note Though +updated_at+ and +updated_at=+ are defined, it will only show up
+    #   in +attributes+ when it is passed in to the initializer or added to +attributes+,
+    #   such as <tt>attributes[:updated_at] = Time.current</tt>.
+    # @return [String, Numeric, Time]
+    def updated_at
+      attributes.fetch(:updated_at) do
+        defined?(@updated_at) ? @updated_at : File.mtime(__FILE__)
+      end
     end
 
-    def self.lookup_ancestors
-      [self]
+    # To customize model behavior, this method must be redefined. However,
+    # there are other ways of setting the +cache_key+ a serializer uses.
+    # @return [String]
+    def cache_key
+      ActiveSupport::Cache.expand_cache_key([
+        self.class.model_name.name.downcase,
+        "#{id}-#{updated_at.strftime('%Y%m%d%H%M%S%9N')}"
+      ].compact)
     end
   end
 end

data/lib/active_model_serializers/railtie.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'rails/railtie'
 require 'action_controller'
 require 'action_controller/railtie'
@@ -5,6 +7,8 @@ require 'action_controller/serialization'
 
 module ActiveModelSerializers
   class Railtie < Rails::Railtie
+    config.eager_load_namespaces << ActiveModelSerializers
+
     config.to_prepare do
       ActiveModel::Serializer.serializers_cache.clear
     end
@@ -23,7 +27,7 @@ module ActiveModelSerializers
     # This hook is run after the action_controller railtie has set the configuration
     # based on the *environment* configuration and before any config/initializers are run
     # and also before eager_loading (if enabled).
-    initializer 'active_model_serializers.set_configs', :after => 'action_controller.set_configs' do
+    initializer 'active_model_serializers.set_configs', after: 'action_controller.set_configs' do
       ActiveModelSerializers.logger = Rails.configuration.action_controller.logger
       ActiveModelSerializers.config.perform_caching = Rails.configuration.action_controller.perform_caching
       # We want this hook to run after the config has been set, even if ActionController has already loaded.
@@ -32,11 +36,13 @@ module ActiveModelSerializers
       end
     end
 
+    # :nocov:
     generators do |app|
       Rails::Generators.configure!(app.config.generators)
       Rails::Generators.hidden_namespaces.uniq!
       require 'generators/rails/resource_override'
     end
+    # :nocov:
 
     if Rails.env.test?
       ActionController::TestCase.send(:include, ActiveModelSerializers::Test::Schema)

data/lib/active_model_serializers/register_jsonapi_renderer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Based on discussion in https://github.com/rails/rails/pull/23712#issuecomment-184977238,
 # the JSON API media type will have its own format/renderer.
 #
@@ -22,43 +24,56 @@
 # render jsonapi: model
 #
 # No wrapper format needed as it does not apply (i.e. no `wrap_parameters format: [jsonapi]`)
+module ActiveModelSerializers
+  module Jsonapi
+    MEDIA_TYPE = 'application/vnd.api+json'.freeze
+    HEADERS = {
+      response: { 'CONTENT_TYPE'.freeze => MEDIA_TYPE },
+      request:  { 'ACCEPT'.freeze => MEDIA_TYPE }
+    }.freeze
 
-module ActiveModelSerializers::Jsonapi
-  MEDIA_TYPE = 'application/vnd.api+json'.freeze
-  HEADERS = {
-    response: { 'CONTENT_TYPE'.freeze => MEDIA_TYPE },
-    request:  { 'ACCEPT'.freeze => MEDIA_TYPE }
-  }.freeze
-  module ControllerSupport
-    def serialize_jsonapi(json, options)
-      options[:adapter] = :json_api
-      options.fetch(:serialization_context) { options[:serialization_context] = ActiveModelSerializers::SerializationContext.new(request) }
-      get_serializer(json, options)
-    end
-  end
-end
+    def self.install
+      # actionpack/lib/action_dispatch/http/mime_types.rb
+      Mime::Type.register MEDIA_TYPE, :jsonapi
+
+      if Rails::VERSION::MAJOR >= 5
+        ActionDispatch::Request.parameter_parsers[:jsonapi] = parser
+      else
+        ActionDispatch::ParamsParser::DEFAULT_PARSERS[Mime[:jsonapi]] = parser
+      end
 
-# actionpack/lib/action_dispatch/http/mime_types.rb
-Mime::Type.register ActiveModelSerializers::Jsonapi::MEDIA_TYPE, :jsonapi
+      # ref https://github.com/rails/rails/pull/21496
+      ActionController::Renderers.add :jsonapi do |json, options|
+        json = serialize_jsonapi(json, options).to_json(options) unless json.is_a?(String)
+        self.content_type ||= Mime[:jsonapi]
+        self.response_body = json
+      end
+    end
 
-parsers = Rails::VERSION::MAJOR >= 5 ? ActionDispatch::Http::Parameters : ActionDispatch::ParamsParser
-media_type = Mime::Type.lookup(ActiveModelSerializers::Jsonapi::MEDIA_TYPE)
+    # Proposal: should actually deserialize the JSON API params
+    # to the hash format expected by `ActiveModel::Serializers::JSON`
+    # actionpack/lib/action_dispatch/http/parameters.rb
+    def self.parser
+      lambda do |body|
+        data = JSON.parse(body)
+        data = { _json: data } unless data.is_a?(Hash)
+        data.with_indifferent_access
+      end
+    end
 
-# Proposal: should actually deserialize the JSON API params
-# to the hash format expected by `ActiveModel::Serializers::JSON`
-# actionpack/lib/action_dispatch/http/parameters.rb
-parsers::DEFAULT_PARSERS[media_type] = lambda do |body|
-  data = JSON.parse(body)
-  data = { :_json => data } unless data.is_a?(Hash)
-  data.with_indifferent_access
+    module ControllerSupport
+      def serialize_jsonapi(json, options)
+        options[:adapter] = :json_api
+        options.fetch(:serialization_context) do
+          options[:serialization_context] = ActiveModelSerializers::SerializationContext.new(request)
+        end
+        get_serializer(json, options)
+      end
+    end
+  end
 end
 
-# ref https://github.com/rails/rails/pull/21496
-ActionController::Renderers.add :jsonapi do |json, options|
-  json = serialize_jsonapi(json, options).to_json(options) unless json.is_a?(String)
-  self.content_type ||= media_type
-  self.response_body = json
-end
+ActiveModelSerializers::Jsonapi.install
 
 ActiveSupport.on_load(:action_controller) do
   include ActiveModelSerializers::Jsonapi::ControllerSupport

data/lib/active_model_serializers/serializable_resource.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 
 module ActiveModelSerializers
@@ -14,8 +16,8 @@ module ActiveModelSerializers
     # @return the serializable_resource, ready for #as_json/#to_json/#serializable_hash.
     def initialize(resource, options = {})
       @resource = resource
-      @adapter_opts, @serializer_opts =
-        options.partition { |k, _| ADAPTER_OPTION_KEYS.include? k }.map { |h| Hash[h] }
+      @adapter_opts = options.select { |k, _| ADAPTER_OPTION_KEYS.include? k }
+      @serializer_opts = options.reject { |k, _| ADAPTER_OPTION_KEYS.include? k }
     end
 
     def serialization_scope=(scope)
@@ -38,9 +40,10 @@ module ActiveModelSerializers
 
     def find_adapter
       return resource unless serializer?
-      ActiveModelSerializers::Adapter.create(serializer_instance, adapter_opts)
-    rescue ActiveModel::Serializer::CollectionSerializer::NoSerializerError
-      resource
+      adapter = catch :no_serializer do
+        ActiveModelSerializers::Adapter.create(serializer_instance, adapter_opts)
+      end
+      adapter || resource
     end
 
     def serializer_instance
@@ -49,12 +52,12 @@ module ActiveModelSerializers
 
     # Get serializer either explicitly :serializer or implicitly from resource
     # Remove :serializer key from serializer_opts
-    # Replace :serializer key with :each_serializer if present
+    # Remove :each_serializer if present and set as :serializer key
     def serializer
       @serializer ||=
         begin
           @serializer = serializer_opts.delete(:serializer)
-          @serializer ||= ActiveModel::Serializer.serializer_for(resource)
+          @serializer ||= ActiveModel::Serializer.serializer_for(resource, serializer_opts)
 
           if serializer_opts.key?(:each_serializer)
             serializer_opts[:serializer] = serializer_opts.delete(:each_serializer)

data/lib/active_model_serializers/serialization_context.rb

@@ -1,3 +1,6 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/array/extract_options'
 module ActiveModelSerializers
   class SerializationContext
     class << self
@@ -22,9 +25,15 @@ module ActiveModelSerializers
 
     attr_reader :request_url, :query_parameters, :key_transform
 
-    def initialize(request, options = {})
-      @request_url = request.original_url[/\A[^?]+/]
-      @query_parameters = request.query_parameters
+    def initialize(*args)
+      options = args.extract_options!
+      if args.size == 1
+        request = args.pop
+        options[:request_url] = request.original_url[/\A[^?]+/]
+        options[:query_parameters] = request.query_parameters
+      end
+      @request_url = options.delete(:request_url)
+      @query_parameters = options.delete(:query_parameters)
       @url_helpers = options.delete(:url_helpers) || self.class.url_helpers
       @default_url_options = options.delete(:default_url_options) || self.class.default_url_options
     end

data/lib/active_model_serializers/test/schema.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModelSerializers
   module Test
     module Schema
@@ -60,11 +62,11 @@ module ActiveModelSerializers
         attr_reader :document_store
 
         def controller_path
-          request.filtered_parameters[:controller]
+          request.filtered_parameters.with_indifferent_access[:controller]
         end
 
         def action
-          request.filtered_parameters[:action]
+          request.filtered_parameters.with_indifferent_access[:action]
         end
 
         def schema_directory

data/lib/active_model_serializers/test/serializer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'set'
 module ActiveModelSerializers
   module Test

data/lib/active_model_serializers/test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveModelSerializers
   module Test
     extend ActiveSupport::Autoload

data/lib/active_model_serializers.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'active_model'
 require 'active_support'
 require 'active_support/core_ext/object/with_options'
@@ -5,15 +7,19 @@ require 'active_support/core_ext/string/inflections'
 require 'active_support/json'
 module ActiveModelSerializers
   extend ActiveSupport::Autoload
-  autoload :Model
-  autoload :Callbacks
-  autoload :Deserialization
-  autoload :SerializableResource
-  autoload :Logging
-  autoload :Test
-  autoload :Adapter
-  autoload :JsonPointer
-  autoload :Deprecate
+  eager_autoload do
+    autoload :Model
+    autoload :Callbacks
+    autoload :SerializableResource
+    autoload :SerializationContext
+    autoload :Logging
+    autoload :Test
+    autoload :Adapter
+    autoload :JsonPointer
+    autoload :Deprecate
+    autoload :LookupChain
+    autoload :Deserialization
+  end
 
   class << self; attr_accessor :logger; end
   self.logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(STDOUT))
@@ -31,8 +37,27 @@ module ActiveModelSerializers
     [file, lineno]
   end
 
+  # Memoized default include directive
+  # @return [JSONAPI::IncludeDirective]
+  def self.default_include_directive
+    @default_include_directive ||= JSONAPI::IncludeDirective.new(config.default_includes, allow_wildcard: true)
+  end
+
+  def self.silence_warnings
+    original_verbose = $VERBOSE
+    $VERBOSE = nil
+    yield
+  ensure
+    $VERBOSE = original_verbose
+  end
+
+  def self.eager_load!
+    super
+    ActiveModel::Serializer.eager_load!
+  end
+
   require 'active_model/serializer/version'
   require 'active_model/serializer'
   require 'active_model/serializable_resource'
-  require 'active_model_serializers/railtie' if defined?(::Rails)
+  require 'active_model_serializers/railtie' if defined?(::Rails::Railtie)
 end

data/lib/generators/rails/resource_override.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'rails/generators'
 require 'rails/generators/rails/resource/resource_generator'
 
 module Rails
   module Generators
     class ResourceGenerator
-      hook_for :serializer, default: true, boolean: true
+      hook_for :serializer, default: true, type: :boolean
     end
   end
 end

data/lib/generators/rails/serializer_generator.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module Rails
   module Generators
     class SerializerGenerator < NamedBase
       source_root File.expand_path('../templates', __FILE__)
-      check_class_collision :suffix => 'Serializer'
+      check_class_collision suffix: 'Serializer'
 
-      argument :attributes, :type => :array, :default => [], :banner => 'field:type field:type'
+      argument :attributes, type: :array, default: [], banner: 'field:type field:type'
 
-      class_option :parent, :type => :string, :desc => 'The parent class for the generated serializer'
+      class_option :parent, type: :string, desc: 'The parent class for the generated serializer'
 
       def create_serializer_file
         template 'serializer.rb.erb', File.join('app/serializers', class_path, "#{file_name}_serializer.rb")
@@ -25,7 +27,7 @@ module Rails
       def parent_class_name
         if options[:parent]
           options[:parent]
-        elsif defined?(::ApplicationSerializer)
+        elsif 'ApplicationSerializer'.safe_constantize
           'ApplicationSerializer'
         else
           'ActiveModel::Serializer'

data/lib/grape/active_model_serializers.rb

@@ -1,14 +1,18 @@
+# frozen_string_literal: true
+
 # To add Grape support, require 'grape/active_model_serializers' in the base of your Grape endpoints
 # Then add 'include Grape::ActiveModelSerializers' to enable the formatter and helpers
 require 'active_model_serializers'
 require 'grape/formatters/active_model_serializers'
 require 'grape/helpers/active_model_serializers'
 
-module Grape::ActiveModelSerializers
-  extend ActiveSupport::Concern
+module Grape
+  module ActiveModelSerializers
+    extend ActiveSupport::Concern
 
-  included do
-    formatter :json, Grape::Formatters::ActiveModelSerializers
-    helpers Grape::Helpers::ActiveModelSerializers
+    included do
+      formatter :json, Grape::Formatters::ActiveModelSerializers
+      helpers Grape::Helpers::ActiveModelSerializers
+    end
   end
 end