dulead-jsonapi-serializer 2.2.0

data/lib/fast_jsonapi/scalar.rb

@@ -0,0 +1,29 @@
+module FastJsonapi
+  class Scalar
+    attr_reader :key, :method, :conditional_proc
+
+    def initialize(key:, method:, options: {})
+      @key = key
+      @method = method
+      @conditional_proc = options[:if]
+    end
+
+    def serialize(record, serialization_params, output_hash)
+      if conditionally_allowed?(record, serialization_params)
+        if method.is_a?(Proc)
+          output_hash[key] = FastJsonapi.call_proc(method, record, serialization_params)
+        else
+          output_hash[key] = record.public_send(method)
+        end
+      end
+    end
+
+    def conditionally_allowed?(record, serialization_params)
+      if conditional_proc.present?
+        FastJsonapi.call_proc(conditional_proc, record, serialization_params)
+      else
+        true
+      end
+    end
+  end
+end

data/lib/fast_jsonapi/serialization_core.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'digest/sha1'
+
+module FastJsonapi
+  MandatoryField = Class.new(StandardError)
+
+  module SerializationCore
+    extend ActiveSupport::Concern
+
+    included do
+      class << self
+        attr_accessor :attributes_to_serialize,
+                      :relationships_to_serialize,
+                      :cachable_relationships_to_serialize,
+                      :uncachable_relationships_to_serialize,
+                      :transform_method,
+                      :record_type,
+                      :record_type_block,
+                      :record_id,
+                      :cache_store_instance,
+                      :cache_store_options,
+                      :data_links,
+                      :meta_to_serialize
+      end
+    end
+
+    class_methods do
+      def id_hash(id, record_type, default_return = false)
+        if id.present?
+          { id: id.to_s, type: record_type }
+        else
+          default_return ? { id: nil, type: record_type } : nil
+        end
+      end
+
+      def links_hash(record, params = {})
+        data_links.each_with_object({}) do |(_k, link), hash|
+          link.serialize(record, params, hash)
+        end
+      end
+
+      def attributes_hash(record, fieldset = nil, params = {})
+        attributes = attributes_to_serialize
+        attributes = attributes.slice(*fieldset) if fieldset.present?
+        attributes = {} if fieldset == []
+
+        attributes.each_with_object({}) do |(_k, attribute), hash|
+          attribute.serialize(record, params, hash)
+        end
+      end
+
+      def relationships_hash(record, relationships = nil, fieldset = nil, includes_list = nil, params = {})
+        relationships = relationships_to_serialize if relationships.nil?
+        relationships = relationships.slice(*fieldset) if fieldset.present?
+        relationships = {} if fieldset == []
+
+        relationships.each_with_object({}) do |(key, relationship), hash|
+          included = includes_list.present? && includes_list.include?(key)
+          relationship.serialize(record, included, params, hash)
+        end
+      end
+
+      def meta_hash(record, params = {})
+        FastJsonapi.call_proc(meta_to_serialize, record, params)
+      end
+
+      def record_hash(record, fieldset, includes_list, params = {})
+        if cache_store_instance
+          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), type_from_record(record, record_type), true)
+            temp_hash[:attributes] = attributes_hash(record, fieldset, params) if attributes_to_serialize.present?
+            temp_hash[:relationships] = relationships_hash(record, cachable_relationships_to_serialize, fieldset, includes_list, params) if cachable_relationships_to_serialize.present?
+            temp_hash[:links] = links_hash(record, params) if data_links.present?
+            temp_hash
+          end
+          record_hash[:relationships] = (record_hash[:relationships] || {}).merge(relationships_hash(record, uncachable_relationships_to_serialize, fieldset, includes_list, params)) if uncachable_relationships_to_serialize.present?
+        else
+          record_hash = id_hash(id_from_record(record, params), type_from_record(record, record_type), true)
+          record_hash[:attributes] = attributes_hash(record, fieldset, params) if attributes_to_serialize.present?
+          record_hash[:relationships] = relationships_hash(record, nil, fieldset, includes_list, params) if relationships_to_serialize.present?
+          record_hash[:links] = links_hash(record, params) if data_links.present?
+        end
+
+        record_hash[:meta] = meta_hash(record, params) if meta_to_serialize.present?
+        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
+        raise MandatoryField, 'id is a mandatory field in the jsonapi spec' unless record.respond_to?(:id)
+
+        record.id
+      end
+
+      def type_from_record(record, record_type)
+        return FastJsonapi.call_proc(record_type_block, record) if record_type_block.is_a?(Proc)
+
+        record_type
+      end
+
+      # 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 = parse_includes_list(includes_list)
+
+        includes_list.each_with_object([]) do |include_item, included_records|
+          relationship_item = relationships_to_serialize[include_item.first]
+
+          next unless relationship_item&.include_relationship?(record, params)
+
+          included_objects = Array(relationship_item.fetch_associated_object(record, params))
+          next if included_objects.empty?
+
+          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
+
+            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.include?(code)
+
+            known_included_objects << code
+
+            included_records << serializer.record_hash(inc_obj, fieldsets[record_type], includes_list, params)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fast_jsonapi/version.rb

@@ -0,0 +1,3 @@
+module FastJsonapi
+  VERSION = JSONAPI::Serializer::VERSION
+end

data/lib/fast_jsonapi.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'jsonapi/serializer/errors'
+
+module FastJsonapi
+  require 'fast_jsonapi/object_serializer'
+  if defined?(::Rails)
+    require 'fast_jsonapi/railtie'
+  elsif defined?(::ActiveRecord)
+    require 'extensions/has_one'
+  end
+end

data/lib/generators/serializer/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Generates a serializer for the given model.
+
+Example:
+    rails generate serializer Movie
+
+    This will create:
+        app/serializers/movie_serializer.rb

data/lib/generators/serializer/serializer_generator.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rails/generators/base'
+
+class SerializerGenerator < Rails::Generators::NamedBase
+  source_root File.expand_path('templates', __dir__)
+
+  argument :attributes, type: :array, default: [], banner: 'field field'
+
+  def create_serializer_file
+    template 'serializer.rb.tt', File.join('app', 'serializers', class_path, "#{file_name}_serializer.rb")
+  end
+
+  private
+
+  def attributes_names
+    attributes.map { |a| a.name.to_sym.inspect }
+  end
+end

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

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

data/lib/jsonapi/serializer/errors.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module JSONAPI
+  module Serializer
+    class Error < StandardError; end
+
+    class UnsupportedIncludeError < Error
+      attr_reader :include_item, :klass
+
+      def initialize(include_item, klass)
+        super()
+        @include_item = include_item
+        @klass = klass
+      end
+
+      def message
+        "#{include_item} is not specified as a relationship on #{klass}"
+      end
+    end
+  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

@@ -0,0 +1,5 @@
+module JSONAPI
+  module Serializer
+    VERSION = '2.2.0'.freeze
+  end
+end

data/lib/jsonapi/serializer.rb

@@ -0,0 +1,12 @@
+require 'fast_jsonapi'
+
+module JSONAPI
+  module Serializer
+    # TODO: Move and cleanup the old implementation...
+    def self.included(base)
+      base.class_eval do
+        include FastJsonapi::ObjectSerializer
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,249 @@
+--- !ruby/object:Gem::Specification
+name: dulead-jsonapi-serializer
+version: !ruby/object:Gem::Version
+  version: 2.2.0
+platform: ruby
+authors:
+- JSON:API Serializer Community
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2022-01-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: ffaker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jsonapi-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.0.5
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-performance
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Fast, simple and easy to use JSON:API serialization library (also known
+  as fast_jsonapi).
+email: ''
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.md
+files:
+- LICENSE.txt
+- README.md
+- lib/extensions/has_one.rb
+- lib/fast_jsonapi.rb
+- lib/fast_jsonapi/attribute.rb
+- lib/fast_jsonapi/helpers.rb
+- lib/fast_jsonapi/instrumentation.rb
+- lib/fast_jsonapi/instrumentation/skylight.rb
+- lib/fast_jsonapi/link.rb
+- lib/fast_jsonapi/object_serializer.rb
+- lib/fast_jsonapi/railtie.rb
+- lib/fast_jsonapi/relationship.rb
+- lib/fast_jsonapi/scalar.rb
+- lib/fast_jsonapi/serialization_core.rb
+- lib/fast_jsonapi/version.rb
+- lib/generators/serializer/USAGE
+- lib/generators/serializer/serializer_generator.rb
+- lib/generators/serializer/templates/serializer.rb.tt
+- lib/jsonapi/serializer.rb
+- lib/jsonapi/serializer/errors.rb
+- lib/jsonapi/serializer/instrumentation.rb
+- lib/jsonapi/serializer/version.rb
+homepage: https://github.com/mnifakram/jsonapi-serializer
+licenses:
+- Apache-2.0
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.2.32
+signing_key:
+specification_version: 4
+summary: Fast JSON:API serialization library
+test_files: []