jsonapi-serializer 2.0.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f9205acf76e6255c2007561530f51eb99f45e8c05fc4e588fcd668870726f383
-  data.tar.gz: 7e43c43899c6cfbd8655754bcd709cc6a5ef640bc50cde5e8791b5435c49f7de
+  metadata.gz: 017a78c672880bd4e5c71443b4d89e6755c2819c2e255fe0fabc634b2eb03b6f
+  data.tar.gz: 849735cbc53db74e8fe00b0b6e35372ee63402c04e8a74df9693d81ab4d10fee
 SHA512:
-  metadata.gz: 40391e6455a9b08ac6ae8790c1623cfb548e31718bf677a0c053943e683f6bd850ebac56ea48fd665eef8f0c246ba182a4e34f962f866e2ee9c3e7883453ff59
-  data.tar.gz: ac99a83e5730734b80022c482cf0afe72d98081381eec7122d29ffe4e4303682f48dbdca31e46d8396a98dac779c87f135b9350b2abdc8980ffcb6d9d8614f69
+  metadata.gz: 35f5960d308078c06bdbdd9d4bd0b735ae8d409f4637b595cb3e1a51b53fea1aaaa37bc7ed871fcdff46429463a0644b30d0626156ab39894e1a0b4fe6dadf16
+  data.tar.gz: 70d5947d310735e7faf1839db897fc7227af7b7407b185fa30ec9622214f78600b86bb419c1c9c16c838d6da5606c6104b566d1bbe6d86817e3f30b70301c647

data/LICENSE.txt

@@ -1,6 +1,6 @@
 Apache License
 Version 2.0, January 2004
-http://www.apache.org/licenses/
+https://www.apache.org/licenses/
 
 TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
@@ -192,7 +192,7 @@ Licensed under the Apache License, Version 2.0 (the "License");
 you may not use this file except in compliance with the License.
 You may obtain a copy of the License at
 
-http://www.apache.org/licenses/LICENSE-2.0
+https://www.apache.org/licenses/LICENSE-2.0
 
 Unless required by applicable law or agreed to in writing, software
 distributed under the License is distributed on an "AS IS" BASIS,

data/README.md

@@ -1,6 +1,6 @@
 # JSON:API Serialization Library
 
-A fast [JSON:API](http://jsonapi.org/) serializer for Ruby Objects.
+A fast [JSON:API](https://jsonapi.org/) serializer for Ruby Objects.
 
 Previously this project was called **fast_jsonapi**, we forked the project
 and renamed it to **jsonapi/serializer** in order to keep it alive.
@@ -38,6 +38,7 @@ article in the `docs` folder for any questions related to methodology.
   * [Specifying a Relationship Serializer](#specifying-a-relationship-serializer)
   * [Sparse Fieldsets](#sparse-fieldsets)
   * [Using helper methods](#using-helper-methods)
+* [Performance Instrumentation](#performance-instrumentation)
 * [Contributing](#contributing)
 
 
@@ -257,18 +258,18 @@ class MovieSerializer
   link :self, :url
 
   link :custom_url do |object|
-    "http://movies.com/#{object.name}-(#{object.year})"
+    "https://movies.com/#{object.name}-(#{object.year})"
   end
 
   link :personalized_url do |object, params|
-    "http://movies.com/#{object.name}-#{params[:user].reference_code}"
+    "https://movies.com/#{object.name}-#{params[:user].reference_code}"
   end
 end
 ```
 
 #### Links on a Relationship
 
-You can specify [relationship links](http://jsonapi.org/format/#document-resource-object-relationships) by using the `links:` option on the serializer. Relationship links in JSON API are useful if you want to load a parent document and then load associated documents later due to size constraints (see [related resource links](http://jsonapi.org/format/#document-resource-object-related-resource-links))
+You can specify [relationship links](https://jsonapi.org/format/#document-resource-object-relationships) by using the `links:` option on the serializer. Relationship links in JSON API are useful if you want to load a parent document and then load associated documents later due to size constraints (see [related resource links](https://jsonapi.org/format/#document-resource-object-related-resource-links))
 
 ```ruby
 class MovieSerializer
@@ -317,6 +318,23 @@ class MovieSerializer
 end
 ```
 
+#### Meta on a Relationship
+
+You can specify [relationship meta](https://jsonapi.org/format/#document-resource-object-relationships) by using the `meta:` option on the serializer. Relationship meta in JSON API is useful if you wish to provide non-standard meta-information about the relationship.
+
+Meta can be defined either by passing a static hash or by using Proc to the `meta` key. In the latter case, the record and any params passed to the serializer are available inside the Proc as the first and second parameters, respectively.
+
+
+```ruby
+class MovieSerializer
+  include JSONAPI::Serializer
+
+  has_many :actors, meta: Proc.new do |movie_record, params|
+    { count: movie_record.actors.length }
+  end
+end
+```
+
 ### Compound Document
 
 Support for top-level and nested included associations through `options[:include]`.
@@ -392,6 +410,25 @@ So for the example above it will call the cache instance like this:
 Rails.cache.fetch(record, namespace: 'jsonapi-serializer', expires_in: 1.hour) { ... }
 ```
 
+#### Caching and Sparse Fieldsets
+
+If caching is enabled and fields are provided to the serializer, the fieldset will be appended to the cache key's namespace.
+
+For example, given the following serializer definition and instance:
+```ruby
+class ActorSerializer
+  include JSONAPI::Serializer
+
+  attributes :first_name, :last_name
+
+  cache_options store: Rails.cache, namespace: 'jsonapi-serializer', expires_in: 1.hour
+end
+
+serializer = ActorSerializer.new(actor, { fields: { actor: [:first_name] } })
+```
+
+The following cache namespace will be generated: `'jsonapi-serializer-fieldset:first_name'`.
+
 ### Params
 
 In some cases, attribute values might require more information than what is
@@ -452,6 +489,13 @@ class MovieSerializer
     # The director will be serialized only if the :admin key of params is true
     params && params[:admin] == true
   }
+
+  # Custom attribute `name_year` will only be serialized if both `name` and `year` fields are present
+  attribute :name_year, if: Proc.new { |record|
+    record.name.present? && record.year.present?
+  } do |object|
+    "#{object.name} - #{object.year}"
+  end
 end
 
 # ...
@@ -619,36 +663,27 @@ serializer | Set custom Serializer for a relationship | `has_many :actors, seria
 polymorphic | Allows different record types for a polymorphic association | `has_many :targets, polymorphic: true`
 polymorphic | Sets custom record types for each object class in a polymorphic association | `has_many :targets, polymorphic: { Person => :person, Group => :group }`
 
-### Instrumentation
+### Performance Instrumentation
 
-`fast_jsonapi` also has builtin [Skylight](https://www.skylight.io/) integration. To enable, add the following to an initializer:
-
-```ruby
-require 'fast_jsonapi/instrumentation/skylight'
-```
+Performance instrumentation is available by using the
+`active_support/notifications`.
 
-Skylight relies on `ActiveSupport::Notifications` to track these two core methods. If you would like to use these notifications without using Skylight, simply require the instrumentation integration:
+To enable it, include the module in your serializer class:
 
 ```ruby
-require 'fast_jsonapi/instrumentation'
-```
-
-The two instrumented notifications are supplied by these two constants:
-* `FastJsonapi::ObjectSerializer::SERIALIZABLE_HASH_NOTIFICATION`
-* `FastJsonapi::ObjectSerializer::SERIALIZED_JSON_NOTIFICATION`
+require 'jsonapi/serializer'
+require 'jsonapi/serializer/instrumentation'
 
-It is also possible to instrument one method without the other by using one of the following require statements:
+class MovieSerializer
+  include JSONAPI::Serializer
+  include JSONAPI::Serializer::Instrumentation
 
-```ruby
-require 'fast_jsonapi/instrumentation/serializable_hash'
-require 'fast_jsonapi/instrumentation/serialized_json'
+  # ...
+end
 ```
 
-Same goes for the Skylight integration:
-```ruby
-require 'fast_jsonapi/instrumentation/skylight/normalizers/serializable_hash'
-require 'fast_jsonapi/instrumentation/skylight/normalizers/serialized_json'
-```
+[Skylight](https://www.skylight.io/) integration is also available and
+supported by us, follow the Skylight documentation to enable it.
 
 ### Running Tests
 The project has and requires unit tests, functional tests and performance
@@ -665,4 +700,4 @@ pull request creation processes.
 
 This project is intended to be a safe, welcoming space for collaboration, and
 contributors are expected to adhere to the
-[Contributor Covenant](http://contributor-covenant.org) code of conduct.
+[Contributor Covenant](https://contributor-covenant.org) code of conduct.

data/lib/fast_jsonapi/instrumentation.rb

@@ -1,2 +1,7 @@
-require 'fast_jsonapi/instrumentation/serializable_hash'
-require 'fast_jsonapi/instrumentation/serialized_json'
+require 'jsonapi/serializer/instrumentation'
+
+warn(
+  'DEPRECATION: Performance instrumentation is no longer automatic. See: ' \
+  'https://github.com/jsonapi-serializer/jsonapi-serializer' \
+  '#performance-instrumentation'
+)

data/lib/fast_jsonapi/instrumentation/skylight.rb

@@ -1,2 +1,3 @@
-require 'fast_jsonapi/instrumentation/skylight/normalizers/serializable_hash'
-require 'fast_jsonapi/instrumentation/skylight/normalizers/serialized_json'
+require 'skylight'
+
+warn('DEPRECATION: Skylight support was moved into the `skylight` gem.')

data/lib/fast_jsonapi/object_serializer.rb

@@ -15,8 +15,6 @@ module FastJsonapi
     extend ActiveSupport::Concern
     include SerializationCore
 
-    SERIALIZABLE_HASH_NOTIFICATION = 'render.fast_jsonapi.serializable_hash'
-    SERIALIZED_JSON_NOTIFICATION = 'render.fast_jsonapi.serialized_json'
     TRANSFORMS_MAPPING = {
       camel: :camelize,
       camel_lower: [:camelize, :lower],
@@ -36,7 +34,9 @@ module FastJsonapi
     end
 
     def serializable_hash
-      return hash_for_collection if is_collection?(@resource, @is_collection)
+      if self.class.is_collection?(@resource, @is_collection)
+        return hash_for_collection
+      end
 
       hash_for_one_record
     end
@@ -80,7 +80,7 @@ module FastJsonapi
 
       return if options.blank?
 
-      @known_included_objects = {}
+      @known_included_objects = Set.new
       @meta = options[:meta]
       @links = options[:links]
       @is_collection = options[:is_collection]
@@ -105,13 +105,16 @@ module FastJsonapi
       end
     end
 
-    def is_collection?(resource, force_is_collection = nil)
-      return force_is_collection unless force_is_collection.nil?
+    class_methods do
+      # Detects a collection/enumerable
+      #
+      # @return [TrueClass] on a successful detection
+      def is_collection?(resource, force_is_collection = nil)
+        return force_is_collection unless force_is_collection.nil?
 
-      resource.respond_to?(:each) && !resource.respond_to?(:each_pair)
-    end
+        resource.is_a?(Enumerable) && !resource.respond_to?(:each_pair)
+      end
 
-    class_methods do
       def inherited(subclass)
         super(subclass)
         subclass.attributes_to_serialize = attributes_to_serialize.dup if attributes_to_serialize.present?
@@ -283,6 +286,7 @@ module FastJsonapi
           polymorphic: polymorphic,
           conditional_proc: options[:if],
           transform_method: @transform_method,
+          meta: options[:meta],
           links: options[:links],
           lazy_load_data: options[:lazy_load_data]
         )
@@ -336,21 +340,11 @@ module FastJsonapi
       def validate_includes!(includes)
         return if includes.blank?
 
-        includes.each do |include_item|
-          klass = self
-          parse_include_item(include_item).each do |parsed_include|
-            relationships_to_serialize = klass.relationships_to_serialize || {}
-            relationship_to_include = relationships_to_serialize[parsed_include]
-            raise ArgumentError, "#{parsed_include} is not specified as a relationship on #{klass.name}" unless relationship_to_include
-
-            if relationship_to_include.static_serializer
-              klass = relationship_to_include.static_serializer
-            else
-              # the serializer may change based on the object (e.g. polymorphic relationships),
-              # so inner relationships cannot be validated
-              break
-            end
-          end
+        parse_includes_list(includes).keys.each do |include_item|
+          relationship_to_include = relationships_to_serialize[include_item]
+          raise ArgumentError, "#{include_item} is not specified as a relationship on #{name}" unless relationship_to_include
+
+          relationship_to_include.static_serializer # called for a side-effect to check for a known serializer class.
         end
       end
     end

data/lib/fast_jsonapi/relationship.rb

@@ -1,6 +1,6 @@
 module FastJsonapi
   class Relationship
-    attr_reader :owner, :key, :name, :id_method_name, :record_type, :object_method_name, :object_block, :serializer, :relationship_type, :cached, :polymorphic, :conditional_proc, :transform_method, :links, :lazy_load_data
+    attr_reader :owner, :key, :name, :id_method_name, :record_type, :object_method_name, :object_block, :serializer, :relationship_type, :cached, :polymorphic, :conditional_proc, :transform_method, :links, :meta, :lazy_load_data
 
     def initialize(
       owner:,
@@ -17,6 +17,7 @@ module FastJsonapi
       conditional_proc:,
       transform_method:,
       links:,
+      meta:,
       lazy_load_data: false
     )
       @owner = owner
@@ -33,6 +34,7 @@ module FastJsonapi
       @conditional_proc = conditional_proc
       @transform_method = transform_method
       @links = links || {}
+      @meta = meta || {}
       @lazy_load_data = lazy_load_data
       @record_types_for = {}
       @serializers_for_name = {}
@@ -44,6 +46,8 @@ module FastJsonapi
 
         output_hash[key] = {}
         output_hash[key][:data] = ids_hash_from_record_and_relationship(record, serialization_params) || empty_case unless lazy_load_data && !included
+
+        add_meta_hash(record, serialization_params, output_hash) if meta.present?
         add_links_hash(record, serialization_params, output_hash) if links.present?
       end
     end
@@ -146,11 +150,19 @@ module FastJsonapi
                                    record.public_send(links)
                                  else
                                    links.each_with_object({}) do |(key, method), hash|
-                                     Link.new(key: key, method: method).serialize(record, params, hash)\
+                                     Link.new(key: key, method: method).serialize(record, params, hash)
                                    end
                                  end
     end
 
+    def add_meta_hash(record, params, output_hash)
+      output_hash[key][:meta] = if meta.is_a?(Proc)
+                                  FastJsonapi.call_proc(meta, record, params)
+                                else
+                                  meta
+                                end
+    end
+
     def run_key_transform(input)
       if transform_method.present?
         input.to_s.send(*transform_method).to_sym

data/lib/fast_jsonapi/serialization_core.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'active_support/concern'
+require 'digest/sha1'
 
 module FastJsonapi
   MandatoryField = Class.new(StandardError)
@@ -66,7 +67,8 @@ module FastJsonapi
 
       def record_hash(record, fieldset, includes_list, params = {})
         if cache_store_instance
-          record_hash = cache_store_instance.fetch(record, **cache_store_options) do
+          cache_opts = record_cache_options(cache_store_options, fieldset, includes_list, params)
+          record_hash = cache_store_instance.fetch(record, **cache_opts) do
             temp_hash = id_hash(id_from_record(record, params), record_type, true)
             temp_hash[:attributes] = attributes_hash(record, fieldset, params) if attributes_to_serialize.present?
             temp_hash[:relationships] = {}
@@ -86,6 +88,37 @@ module FastJsonapi
         record_hash
       end
 
+      # Cache options helper. Use it to adapt cache keys/rules.
+      #
+      # If a fieldset is specified, it modifies the namespace to include the
+      # fields from the fieldset.
+      #
+      # @param options [Hash] default cache options
+      # @param fieldset [Array, nil] passed fieldset values
+      # @param includes_list [Array, nil] passed included values
+      # @param params [Hash] the serializer params
+      #
+      # @return [Hash] processed options hash
+      # rubocop:disable Lint/UnusedMethodArgument
+      def record_cache_options(options, fieldset, includes_list, params)
+        return options unless fieldset
+
+        options = options ? options.dup : {}
+        options[:namespace] ||= 'jsonapi-serializer'
+
+        fieldset_key = fieldset.join('_')
+
+        # Use a fixed-length fieldset key if the current length is more than
+        # the length of a SHA1 digest
+        if fieldset_key.length > 40
+          fieldset_key = Digest::SHA1.hexdigest(fieldset_key)
+        end
+
+        options[:namespace] = "#{options[:namespace]}-fieldset:#{fieldset_key}"
+        options
+      end
+      # rubocop:enable Lint/UnusedMethodArgument
+
       def id_from_record(record, params)
         return FastJsonapi.call_proc(record_id, record, params) if record_id.is_a?(Proc)
         return record.send(record_id) if record_id
@@ -94,58 +127,73 @@ module FastJsonapi
         record.id
       end
 
-      def parse_include_item(include_item)
-        return [include_item.to_sym] unless include_item.to_s.include?('.')
-
-        include_item.to_s.split('.').map!(&:to_sym)
-      end
-
-      def remaining_items(items)
-        return unless items.size > 1
-
-        [items[1..-1].join('.').to_sym]
+      # It chops out the root association (first part) from each include.
+      #
+      # It keeps an unique list and collects all of the rest of the include
+      # value to hand it off to the next related to include serializer.
+      #
+      # This method will turn that include array into a Hash that looks like:
+      #
+      #   {
+      #       authors: Set.new([
+      #         'books',
+      #         'books.genre',
+      #         'books.genre.books',
+      #         'books.genre.books.authors',
+      #         'books.genre.books.genre'
+      #       ]),
+      #       genre: Set.new(['books'])
+      #   }
+      #
+      # Because the serializer only cares about the root associations
+      # included, it only needs the first segment of each include
+      # (for books, it's the "authors" and "genre") and it doesn't need to
+      # waste cycles parsing the rest of the include value. That will be done
+      # by the next serializer in line.
+      #
+      # @param includes_list [List] to be parsed
+      # @return [Hash]
+      def parse_includes_list(includes_list)
+        includes_list.each_with_object({}) do |include_item, include_sets|
+          include_base, include_remainder = include_item.to_s.split('.', 2)
+          include_sets[include_base.to_sym] ||= Set.new
+          include_sets[include_base.to_sym] << include_remainder if include_remainder
+        end
       end
 
       # includes handler
       def get_included_records(record, includes_list, known_included_objects, fieldsets, params = {})
         return unless includes_list.present?
+        return [] unless relationships_to_serialize
 
-        includes_list.sort.each_with_object([]) do |include_item, included_records|
-          items = parse_include_item(include_item)
-          remaining_items = remaining_items(items)
-
-          items.each do |item|
-            next unless relationships_to_serialize && relationships_to_serialize[item]
+        includes_list = parse_includes_list(includes_list)
 
-            relationship_item = relationships_to_serialize[item]
-            next unless relationship_item.include_relationship?(record, params)
+        includes_list.each_with_object([]) do |include_item, included_records|
+          relationship_item = relationships_to_serialize[include_item.first]
 
-            relationship_type = relationship_item.relationship_type
+          next unless relationship_item&.include_relationship?(record, params)
 
-            included_objects = relationship_item.fetch_associated_object(record, params)
-            next if included_objects.blank?
+          included_objects = Array(relationship_item.fetch_associated_object(record, params))
+          next if included_objects.empty?
 
-            included_objects = [included_objects] unless relationship_type == :has_many
+          static_serializer = relationship_item.static_serializer
+          static_record_type = relationship_item.static_record_type
 
-            static_serializer = relationship_item.static_serializer
-            static_record_type = relationship_item.static_record_type
+          included_objects.each do |inc_obj|
+            serializer = static_serializer || relationship_item.serializer_for(inc_obj, params)
+            record_type = static_record_type || serializer.record_type
 
-            included_objects.each do |inc_obj|
-              serializer = static_serializer || relationship_item.serializer_for(inc_obj, params)
-              record_type = static_record_type || serializer.record_type
-
-              if remaining_items.present?
-                serializer_records = serializer.get_included_records(inc_obj, remaining_items, known_included_objects, fieldsets, params)
-                included_records.concat(serializer_records) unless serializer_records.empty?
-              end
+            if include_item.last.any?
+              serializer_records = serializer.get_included_records(inc_obj, include_item.last, known_included_objects, fieldsets, params)
+              included_records.concat(serializer_records) unless serializer_records.empty?
+            end
 
-              code = "#{record_type}_#{serializer.id_from_record(inc_obj, params)}"
-              next if known_included_objects.key?(code)
+            code = "#{record_type}_#{serializer.id_from_record(inc_obj, params)}"
+            next if known_included_objects.include?(code)
 
-              known_included_objects[code] = inc_obj
+            known_included_objects << code
 
-              included_records << serializer.record_hash(inc_obj, fieldsets[record_type], includes_list, params)
-            end
+            included_records << serializer.record_hash(inc_obj, fieldsets[record_type], includes_list, params)
           end
         end
       end

data/lib/generators/serializer/templates/serializer.rb.tt

@@ -1,6 +1,6 @@
 <% module_namespacing do -%>
 class <%= class_name %>Serializer
-  include FastJsonapi::ObjectSerializer
+  include JSONAPI::Serializer
   attributes <%= attributes_names.join(", ") %>
 end
 <% end -%>

data/lib/jsonapi/serializer/instrumentation.rb

@@ -0,0 +1,27 @@
+require 'active_support/notifications'
+
+module JSONAPI
+  module Serializer
+    # Support for instrumentation
+    module Instrumentation
+      # Performance instrumentation namespace
+      NOTIFICATION_NAMESPACE = 'render.jsonapi-serializer.'.freeze
+
+      # Patch methods to use instrumentation...
+      %w[
+        serializable_hash
+        get_included_records
+        relationships_hash
+      ].each do |method_name|
+        define_method(method_name) do |*args|
+          ActiveSupport::Notifications.instrument(
+            NOTIFICATION_NAMESPACE + method_name,
+            { name: self.class.name, serializer: self.class }
+          ) do
+            super(*args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jsonapi/serializer/version.rb

@@ -1,5 +1,5 @@
 module JSONAPI
   module Serializer
-    VERSION = '2.0.0'.freeze
+    VERSION = '2.1.0'.freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi-serializer
 version: !ruby/object:Gem::Version
-  version: 2.0.0
+  version: 2.1.0
 platform: ruby
 authors:
 - JSON:API Serializer Community
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-06-22 00:00:00.000000000 Z
+date: 2020-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -86,14 +86,14 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.5
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.0.5
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -208,12 +208,7 @@ files:
 - lib/fast_jsonapi/attribute.rb
 - lib/fast_jsonapi/helpers.rb
 - lib/fast_jsonapi/instrumentation.rb
-- lib/fast_jsonapi/instrumentation/serializable_hash.rb
-- lib/fast_jsonapi/instrumentation/serialized_json.rb
 - lib/fast_jsonapi/instrumentation/skylight.rb
-- lib/fast_jsonapi/instrumentation/skylight/normalizers/base.rb
-- lib/fast_jsonapi/instrumentation/skylight/normalizers/serializable_hash.rb
-- lib/fast_jsonapi/instrumentation/skylight/normalizers/serialized_json.rb
 - lib/fast_jsonapi/link.rb
 - lib/fast_jsonapi/object_serializer.rb
 - lib/fast_jsonapi/railtie.rb
@@ -225,8 +220,9 @@ files:
 - lib/generators/serializer/serializer_generator.rb
 - lib/generators/serializer/templates/serializer.rb.tt
 - lib/jsonapi/serializer.rb
+- lib/jsonapi/serializer/instrumentation.rb
 - lib/jsonapi/serializer/version.rb
-homepage: http://github.com/jsonapi-serializer/jsonapi-serializer
+homepage: https://github.com/jsonapi-serializer/jsonapi-serializer
 licenses:
 - Apache-2.0
 metadata: {}

data/lib/fast_jsonapi/instrumentation/serializable_hash.rb

@@ -1,13 +0,0 @@
-require 'active_support/notifications'
-
-module FastJsonapi
-  module ObjectSerializer
-    alias serializable_hash_without_instrumentation serializable_hash
-
-    def serializable_hash
-      ActiveSupport::Notifications.instrument(SERIALIZABLE_HASH_NOTIFICATION, { name: self.class.name }) do
-        serializable_hash_without_instrumentation
-      end
-    end
-  end
-end

data/lib/fast_jsonapi/instrumentation/serialized_json.rb

@@ -1,13 +0,0 @@
-require 'active_support/notifications'
-
-module FastJsonapi
-  module ObjectSerializer
-    alias serialized_json_without_instrumentation serialized_json
-
-    def serialized_json
-      ActiveSupport::Notifications.instrument(SERIALIZED_JSON_NOTIFICATION, { name: self.class.name }) do
-        serialized_json_without_instrumentation
-      end
-    end
-  end
-end

data/lib/fast_jsonapi/instrumentation/skylight/normalizers/base.rb

@@ -1,7 +0,0 @@
-require 'skylight'
-
-SKYLIGHT_NORMALIZER_BASE_CLASS = begin
-  ::Skylight::Core::Normalizers::Normalizer
-                                 rescue NameError
-                                   ::Skylight::Normalizers::Normalizer
-end

data/lib/fast_jsonapi/instrumentation/skylight/normalizers/serializable_hash.rb

@@ -1,20 +0,0 @@
-require 'fast_jsonapi/instrumentation/skylight/normalizers/base'
-require 'fast_jsonapi/instrumentation/serializable_hash'
-
-module FastJsonapi
-  module Instrumentation
-    module Skylight
-      module Normalizers
-        class SerializableHash < SKYLIGHT_NORMALIZER_BASE_CLASS
-          register FastJsonapi::ObjectSerializer::SERIALIZABLE_HASH_NOTIFICATION
-
-          CAT = "view.#{FastJsonapi::ObjectSerializer::SERIALIZABLE_HASH_NOTIFICATION}".freeze
-
-          def normalize(_trace, _name, payload)
-            [CAT, payload[:name], nil]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fast_jsonapi/instrumentation/skylight/normalizers/serialized_json.rb

@@ -1,20 +0,0 @@
-require 'fast_jsonapi/instrumentation/skylight/normalizers/base'
-require 'fast_jsonapi/instrumentation/serializable_hash'
-
-module FastJsonapi
-  module Instrumentation
-    module Skylight
-      module Normalizers
-        class SerializedJson < SKYLIGHT_NORMALIZER_BASE_CLASS
-          register FastJsonapi::ObjectSerializer::SERIALIZED_JSON_NOTIFICATION
-
-          CAT = "view.#{FastJsonapi::ObjectSerializer::SERIALIZED_JSON_NOTIFICATION}".freeze
-
-          def normalize(_trace, _name, payload)
-            [CAT, payload[:name], nil]
-          end
-        end
-      end
-    end
-  end
-end