active_model_serializers 0.9.0 → 0.10.12

data/lib/active_model_serializers/json_pointer.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ActiveModelSerializers
+  module JsonPointer
+    module_function
+
+    POINTERS = {
+      attribute:    '/data/attributes/%s'.freeze,
+      primary_data: '/data%s'.freeze
+    }.freeze
+
+    def new(pointer_type, value = nil)
+      format(POINTERS[pointer_type], value)
+    end
+  end
+end

data/lib/active_model_serializers/logging.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+##
+# ActiveModelSerializers::Logging
+#
+#   https://github.com/rails/rails/blob/280654ef88/activejob/lib/active_job/logging.rb
+#
+module ActiveModelSerializers
+  module Logging
+    RENDER_EVENT = 'render.active_model_serializers'.freeze
+    extend ActiveSupport::Concern
+
+    included do
+      include ActiveModelSerializers::Callbacks
+      extend Macros
+      instrument_rendering
+    end
+
+    module ClassMethods
+      def instrument_rendering
+        around_render do |args, block|
+          tag_logger do
+            notify_render do
+              block.call(args)
+            end
+          end
+        end
+      end
+    end
+
+    # Macros that can be used to customize the logging of class or instance methods,
+    # by extending the class or its singleton.
+    #
+    # Adapted from:
+    #   https://github.com/rubygems/rubygems/blob/cb28f5e991/lib/rubygems/deprecate.rb
+    #
+    # Provides a single method +notify+ to be used to declare when
+    # something a method notifies, with the argument +callback_name+ of the notification callback.
+    #
+    #     class Adapter
+    #       def self.klass_method
+    #         # ...
+    #       end
+    #
+    #       def instance_method
+    #         # ...
+    #       end
+    #
+    #       include ActiveModelSerializers::Logging::Macros
+    #       notify :instance_method, :render
+    #
+    #       class << self
+    #         extend ActiveModelSerializers::Logging::Macros
+    #         notify :klass_method, :render
+    #       end
+    #     end
+    module Macros
+      ##
+      # Simple notify method that wraps up +name+
+      # in a dummy method. It notifies on with the +callback_name+ notifier on
+      # each call to the dummy method, telling what the current serializer and adapter
+      # are being rendered.
+      # Adapted from:
+      #   https://github.com/rubygems/rubygems/blob/cb28f5e991/lib/rubygems/deprecate.rb
+      def notify(name, callback_name)
+        class_eval do
+          old = "_notifying_#{callback_name}_#{name}"
+          alias_method old, name
+          define_method name do |*args, &block|
+            run_callbacks callback_name do
+              send old, *args, &block
+            end
+          end
+        end
+      end
+    end
+
+    def notify_render(*)
+      event_name = RENDER_EVENT
+      ActiveSupport::Notifications.instrument(event_name, notify_render_payload) do
+        yield
+      end
+    end
+
+    def notify_render_payload
+      {
+        serializer: serializer || ActiveModel::Serializer::Null,
+        adapter: adapter || ActiveModelSerializers::Adapter::Null
+      }
+    end
+
+    private
+
+    def tag_logger(*tags)
+      if ActiveModelSerializers.logger.respond_to?(:tagged)
+        tags.unshift 'active_model_serializers'.freeze unless logger_tagged_by_active_model_serializers?
+        ActiveModelSerializers.logger.tagged(*tags) { yield }
+      else
+        yield
+      end
+    end
+
+    def logger_tagged_by_active_model_serializers?
+      ActiveModelSerializers.logger.formatter.current_tags.include?('active_model_serializers'.freeze)
+    end
+
+    class LogSubscriber < ActiveSupport::LogSubscriber
+      def render(event)
+        info do
+          serializer = event.payload[:serializer]
+          adapter = event.payload[:adapter]
+          duration = event.duration.round(2)
+          "Rendered #{serializer.name} with #{adapter.class} (#{duration}ms)"
+        end
+      end
+
+      def logger
+        ActiveModelSerializers.logger
+      end
+    end
+  end
+end
+
+ActiveModelSerializers::Logging::LogSubscriber.attach_to :active_model_serializers

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

@@ -0,0 +1,132 @@
+# 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::Serializers::JSON
+    include ActiveModel::Model
+
+    # 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 = []
+
+    # 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
+
+    # Opt-in to breaking change
+    def self.derive_attributes_from_names_and_fix_accessors
+      unless included_modules.include?(DeriveAttributesFromNamesAndFixAccessors)
+        prepend(DeriveAttributesFromNamesAndFixAccessors)
+      end
+    end
+
+    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
+
+    # 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
+
+    # 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
+
+    # 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
+
+    # 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/model/caching.rb

@@ -0,0 +1,25 @@
+module ActiveModelSerializers
+  class Model
+    module Caching
+      extend ActiveSupport::Concern
+
+      included do
+        attr_writer :updated_at
+        attributes :id
+      end
+
+      # Defaults to the downcased model name and updated_at
+      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
+
+      # Defaults to the time the serializer file was modified.
+      def updated_at
+        defined?(@updated_at) ? @updated_at : File.mtime(__FILE__)
+      end
+    end
+  end
+end

data/lib/active_model_serializers/railtie.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'rails/railtie'
+require 'action_controller'
+require 'action_controller/railtie'
+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
+
+    initializer 'active_model_serializers.action_controller' do
+      ActiveSupport.on_load(:action_controller) do
+        include(::ActionController::Serialization)
+      end
+    end
+
+    initializer 'active_model_serializers.prepare_serialization_context' do
+      SerializationContext.url_helpers = Rails.application.routes.url_helpers
+      SerializationContext.default_url_options = Rails.application.routes.default_url_options
+    end
+
+    # 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
+      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.
+      ActiveSupport.on_load(:action_controller) do
+        ActiveModelSerializers.config.cache_store = ActionController::Base.cache_store
+      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)
+      ActionController::TestCase.send(:include, ActiveModelSerializers::Test::Serializer)
+    end
+  end
+end

data/lib/active_model_serializers/register_jsonapi_renderer.rb

@@ -0,0 +1,80 @@
+# 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.
+#
+# > We recommend the media type be registered on its own as jsonapi
+# when a jsonapi Renderer and deserializer (Http::Parameters::DEFAULT_PARSERS) are added.
+#
+# Usage:
+#
+# ActiveSupport.on_load(:action_controller) do
+#   require 'active_model_serializers/register_jsonapi_renderer'
+# end
+#
+# And then in controllers, use `render jsonapi: model` rather than `render json: model, adapter: :json_api`.
+#
+# For example, in a controller action, we can:
+# respond_to do |format|
+#   format.jsonapi { render jsonapi: model }
+# end
+#
+# or
+#
+# 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
+
+    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
+
+      # 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
+
+    # 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
+
+    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
+
+ActiveModelSerializers::Jsonapi.install
+
+ActiveSupport.on_load(:action_controller) do
+  include ActiveModelSerializers::Jsonapi::ControllerSupport
+end