agi_active_model_serializers 0.10.7

data/lib/active_model_serializers/adapter/json_api/pagination_links.rb

@@ -0,0 +1,69 @@
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi < Base
+      class PaginationLinks
+        MissingSerializationContextError = Class.new(KeyError)
+        FIRST_PAGE = 1
+
+        attr_reader :collection, :context
+
+        def initialize(collection, adapter_options)
+          @collection = collection
+          @adapter_options = adapter_options
+          @context = adapter_options.fetch(:serialization_context) do
+            fail MissingSerializationContextError, <<-EOF.freeze
+ JsonApi::PaginationLinks requires a ActiveModelSerializers::SerializationContext.
+ Please pass a ':serialization_context' option or
+ override CollectionSerializer#paginated? to return 'false'.
+             EOF
+          end
+        end
+
+        def as_json
+          per_page = collection.try(:per_page) || collection.try(:limit_value) || collection.size
+          pages_from.each_with_object({}) do |(key, value), hash|
+            params = query_parameters.merge(page: { number: value, size: per_page }).to_query
+
+            hash[key] = "#{url(adapter_options)}?#{params}"
+          end
+        end
+
+        protected
+
+        attr_reader :adapter_options
+
+        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

data/lib/active_model_serializers/adapter/json_api/relationship.rb

@@ -0,0 +1,63 @@
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class Relationship
+        # {http://jsonapi.org/format/#document-resource-object-related-resource-links Document Resource Object Related Resource Links}
+        # {http://jsonapi.org/format/#document-links Document Links}
+        # {http://jsonapi.org/format/#document-resource-object-linkage Document Resource Relationship Linkage}
+        # {http://jsonapi.org/format/#document-meta Document Meta}
+        def initialize(parent_serializer, serializable_resource_options, association)
+          @parent_serializer = parent_serializer
+          @association = association
+          @serializable_resource_options = serializable_resource_options
+        end
+
+        def as_json
+          hash = {}
+
+          if association.options[:include_data]
+            hash[:data] = data_for(association)
+          end
+
+          links = links_for(association)
+          hash[:links] = links if links.any?
+
+          meta = meta_for(association)
+          hash[:meta] = meta if meta
+          hash[:meta] = {} if hash.empty?
+
+          hash
+        end
+
+        protected
+
+        attr_reader :parent_serializer, :serializable_resource_options, :association
+
+        private
+
+        def data_for(association)
+          serializer = association.serializer
+          if serializer.respond_to?(:each)
+            serializer.map { |s| ResourceIdentifier.new(s, serializable_resource_options).as_json }
+          elsif (virtual_value = association.options[:virtual_value])
+            virtual_value
+          elsif serializer && serializer.object
+            ResourceIdentifier.new(serializer, serializable_resource_options).as_json
+          end
+        end
+
+        def links_for(association)
+          association.links.each_with_object({}) do |(key, value), hash|
+            result = Link.new(parent_serializer, value).as_json
+            hash[key] = result if result
+          end
+        end
+
+        def meta_for(association)
+          meta = association.meta
+          meta.respond_to?(:call) ? parent_serializer.instance_eval(&meta) : meta
+        end
+      end
+    end
+  end
+end

data/lib/active_model_serializers/adapter/json_api/resource_identifier.rb

@@ -0,0 +1,51 @@
+module ActiveModelSerializers
+  module Adapter
+    class JsonApi
+      class ResourceIdentifier
+        def self.type_for(class_name, serializer_type = nil, transform_options = {})
+          if serializer_type
+            raw_type = serializer_type
+          else
+            inflection =
+              if ActiveModelSerializers.config.jsonapi_resource_type == :singular
+                :singularize
+              else
+                :pluralize
+              end
+
+            raw_type = class_name.underscore
+            raw_type = ActiveSupport::Inflector.public_send(inflection, raw_type)
+            raw_type
+              .gsub!('/'.freeze, ActiveModelSerializers.config.jsonapi_namespace_separator)
+            raw_type
+          end
+          JsonApi.send(:transform_key_casing!, raw_type, transform_options)
+        end
+
+        # {http://jsonapi.org/format/#document-resource-identifier-objects Resource Identifier Objects}
+        def initialize(serializer, options)
+          @id   = id_for(serializer)
+          @type = type_for(serializer, options)
+        end
+
+        def as_json
+          { id: id, type: type }
+        end
+
+        protected
+
+        attr_reader :id, :type
+
+        private
+
+        def type_for(serializer, transform_options)
+          self.class.type_for(serializer.object.class.name, serializer._type, transform_options)
+        end
+
+        def id_for(serializer)
+          serializer.read_attribute_for_serialization(:id).to_s
+        end
+      end
+    end
+  end
+end

data/lib/active_model_serializers/adapter/null.rb

@@ -0,0 +1,9 @@
+module ActiveModelSerializers
+  module Adapter
+    class Null < Base
+      def serializable_hash(*)
+        {}
+      end
+    end
+  end
+end

data/lib/active_model_serializers/callbacks.rb

@@ -0,0 +1,55 @@
+# Adapted from
+# https://github.com/rails/rails/blob/7f18ea14c8/activejob/lib/active_job/callbacks.rb
+require 'active_support/callbacks'
+
+module ActiveModelSerializers
+  # = ActiveModelSerializers Callbacks
+  #
+  # ActiveModelSerializers provides hooks during the life cycle of serialization and
+  # allow you to trigger logic. Available callbacks are:
+  #
+  # * <tt>around_render</tt>
+  #
+  module Callbacks
+    extend ActiveSupport::Concern
+    include ActiveSupport::Callbacks
+
+    included do
+      define_callbacks :render
+    end
+
+    # These methods will be included into any ActiveModelSerializers object, adding
+    # callbacks for +render+.
+    module ClassMethods
+      # Defines a callback that will get called around the render method,
+      # whether it is as_json, to_json, or serializable_hash
+      #
+      #   class ActiveModelSerializers::SerializableResource
+      #     include ActiveModelSerializers::Callbacks
+      #
+      #     around_render do |args, block|
+      #       tag_logger do
+      #         notify_render do
+      #           block.call(args)
+      #         end
+      #       end
+      #     end
+      #
+      #     def as_json
+      #       run_callbacks :render do
+      #         adapter.as_json
+      #       end
+      #     end
+      #     # Note: So that we can re-use the instrumenter for as_json, to_json, and
+      #     # serializable_hash, we aren't using the usual format, which would be:
+      #     # def render(args)
+      #     #   adapter.as_json
+      #     # end
+      #   end
+      #
+      def around_render(*filters, &blk)
+        set_callback(:render, :around, *filters, &blk)
+      end
+    end
+  end
+end

data/lib/active_model_serializers/deprecate.rb

@@ -0,0 +1,54 @@
+##
+# Provides a single method +deprecate+ to be used to declare when
+# something is going away.
+#
+#     class Legacy
+#       def self.klass_method
+#         # ...
+#       end
+#
+#       def instance_method
+#         # ...
+#       end
+#
+#       extend ActiveModelSerializers::Deprecate
+#       deprecate :instance_method, "ActiveModelSerializers::NewPlace#new_method"
+#
+#       class << self
+#         extend ActiveModelSerializers::Deprecate
+#         deprecate :klass_method, :none
+#       end
+#     end
+#
+# Adapted from https://github.com/rubygems/rubygems/blob/1591331/lib/rubygems/deprecate.rb
+module ActiveModelSerializers
+  module Deprecate
+    ##
+    # Simple deprecation method that deprecates +name+ by wrapping it up
+    # in a dummy method. It warns on each call to the dummy method
+    # telling the user of +replacement+ (unless +replacement+ is :none) that it is planned to go away.
+
+    def deprecate(name, replacement)
+      old = "_deprecated_#{name}"
+      alias_method old, name
+      class_eval do
+        define_method(name) do |*args, &block|
+          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(':')}"]
+          warn "#{msg.join}."
+          send old, *args, &block
+        end
+      end
+    end
+
+    def delegate_and_deprecate(method, delegee)
+      delegate method, to: delegee
+      deprecate method, "#{delegee.name}."
+    end
+
+    module_function :deprecate
+    module_function :delegate_and_deprecate
+  end
+end

data/lib/active_model_serializers/deserialization.rb

@@ -0,0 +1,15 @@
+module ActiveModelSerializers
+  module Deserialization
+    module_function
+
+    def jsonapi_parse(*args)
+      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

@@ -0,0 +1,14 @@
+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,122 @@
+##
+# 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