lp-serializable 0.1.0 → 1.0.0

data/lib/fast_jsonapi/serialization_core.rb

@@ -0,0 +1,189 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'fast_jsonapi/multi_to_json'
+
+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_id,
+                      :cache_length,
+                      :race_condition_ttl,
+                      :cached,
+                      :data_links
+      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 ids_hash(ids, record_type)
+        return ids.map { |id| id_hash(id, record_type) } if ids.respond_to? :map
+        id_hash(ids, record_type) # ids variable is just a single id here
+      end
+
+      def id_hash_from_record(record, record_types)
+        # memoize the record type within the record_types dictionary, then assigning to record_type:
+        record_type = record_types[record.class] ||= record.class.name.underscore.to_sym
+        id_hash(record.id, record_type)
+      end
+
+      def ids_hash_from_record_and_relationship(record, relationship, params = {})
+        polymorphic = relationship[:polymorphic]
+
+        return ids_hash(
+          fetch_id(record, relationship, params),
+          relationship[:record_type]
+        ) unless polymorphic
+
+        return unless associated_object = fetch_associated_object(record, relationship, params)
+
+        return associated_object.map do |object|
+          id_hash_from_record object, polymorphic
+        end if associated_object.respond_to? :map
+
+        id_hash_from_record associated_object, polymorphic
+      end
+
+      def links_hash(record, params = {})
+        data_links.each_with_object({}) do |(key, method), link_hash|
+          link_hash[key] = if method.is_a?(Proc)
+            method.arity == 1 ? method.call(record) : method.call(record, params)
+          else
+            record.public_send(method)
+          end
+        end
+      end
+
+      def attributes_hash(record, params = {})
+        attributes = attributes_to_serialize
+        attributes.each_with_object({}) do |(_k, attribute), hash|
+          attribute.serialize(record, params, hash)
+        end
+      end
+
+      def relationships_hash(record, relationships = nil, params = {})
+        relationships = relationships_to_serialize if relationships.nil?
+
+        relationships.each_with_object({}) do |(_k, relationship), hash|
+          name = relationship[:key]
+          empty_case = relationship[:relationship_type] == :has_many ? [] : nil
+          hash[name] = {
+            data: ids_hash_from_record_and_relationship(record, relationship, params) || empty_case
+          }
+        end
+      end
+
+      def record_hash(record, params = {})
+        if cached
+          record_hash = Rails.cache.fetch(record.cache_key, expires_in: cache_length, race_condition_ttl: race_condition_ttl) do
+            temp_hash = id_hash(id_from_record(record), record_type, true)
+            temp_hash[:attributes] = attributes_hash(record, params) if attributes_to_serialize.present?
+            temp_hash[:relationships] = {}
+            temp_hash[:relationships] = relationships_hash(record, cachable_relationships_to_serialize, 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, params)) if uncachable_relationships_to_serialize.present?
+          record_hash
+        else
+          record_hash = id_hash(id_from_record(record), record_type, true)
+          record_hash[:attributes] = attributes_hash(record, params) if attributes_to_serialize.present?
+          record_hash[:relationships] = relationships_hash(record, nil, params) if relationships_to_serialize.present?
+          record_hash[:links] = links_hash(record, params) if data_links.present?
+          record_hash
+        end
+      end
+
+      def id_from_record(record)
+         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
+
+      # Override #to_json for alternative implementation
+      def to_json(payload)
+        FastJsonapi::MultiToJson.to_json(payload) if payload.present?
+      end
+
+      def parse_include_item(include_item)
+        return [include_item.to_sym] unless include_item.to_s.include?('.')
+        include_item.to_s.split('.').map { |item| item.to_sym }
+      end
+
+      def remaining_items(items)
+        return unless items.size > 1
+
+        items_copy = items.dup
+        items_copy.delete_at(0)
+        [items_copy.join('.').to_sym]
+      end
+
+      # includes handler
+      def get_included_records(record, includes_list, known_included_objects, params = {})
+        return unless includes_list.present?
+
+        includes_list.sort.each_with_object([]) do |include_item, included_records|
+          items = parse_include_item(include_item)
+          items.each do |item|
+            next unless relationships_to_serialize && relationships_to_serialize[item]
+            raise NotImplementedError if @relationships_to_serialize[item][:polymorphic].is_a?(Hash)
+            record_type = @relationships_to_serialize[item][:record_type]
+            serializer = @relationships_to_serialize[item][:serializer].to_s.constantize
+            relationship_type = @relationships_to_serialize[item][:relationship_type]
+
+            included_objects = fetch_associated_object(record, @relationships_to_serialize[item], params)
+            next if included_objects.blank?
+            included_objects = [included_objects] unless relationship_type == :has_many
+
+            included_objects.each do |inc_obj|
+              if remaining_items(items)
+                serializer_records = serializer.get_included_records(inc_obj, remaining_items(items), known_included_objects)
+                included_records.concat(serializer_records) unless serializer_records.empty?
+              end
+
+              code = "#{record_type}_#{inc_obj.id}"
+              next if known_included_objects.key?(code)
+
+              known_included_objects[code] = inc_obj
+              included_records << serializer.record_hash(inc_obj, params)
+            end
+          end
+        end
+      end
+
+      def fetch_associated_object(record, relationship, params)
+        return relationship[:object_block].call(record, params) unless relationship[:object_block].nil?
+        record.send(relationship[:object_method_name])
+      end
+
+      def fetch_id(record, relationship, params)
+        unless relationship[:object_block].nil?
+          object = relationship[:object_block].call(record, params)
+
+          return object.map(&:id) if object.respond_to? :map
+          return object.id
+        end
+
+        record.public_send(relationship[:id_method_name])
+      end
+    end
+  end
+end

data/lib/lp/serializable.rb

@@ -1,32 +1,44 @@
-require "lp/serializable/version"
 require "lp/serializable/strategies"
+require "lp/serializable/exceptions"
 
 module Lp
   module Serializable
     include Strategies
+    include Exceptions
 
-    class UnserializableCollection < StandardError
-      def initialize(msg='Expected an object, but a collection was given.')
-        super
-      end
-    end
-
-    def serialize_and_flatten(resource, options={})
-      base_hash = serialize_hash(resource)
+    def serialize_and_flatten(resource, options = {})
+      collection_option = collection?(false)
+      base_hash = serialize_hash(resource, options.merge(collection_option))
       flatten_and_nest_data(base_hash, set_nested_option(options))
     end
 
-    def serialize_and_flatten_with_class_name(resource, class_name, options={})
-      raise UnserializableCollection if resource.is_a?(Array) 
-      base_hash = serializable_hash_with_class_name(resource, 
-        class_name, options)
+    def serialize_and_flatten_with_class_name(
+      resource,
+      class_name,
+      options = {}
+    )
+      raise UnserializableCollection if resource.is_a?(Array)
+      collection_option = collection?(false)
+      base_hash = serializable_hash_with_class_name(
+        resource,
+        class_name,
+        options.merge(collection_option),
+      )
       flatten_and_nest_data(base_hash, set_nested_option(options))
     end
 
-    def serialize_and_flatten_collection(resource, class_name, options={})
-      base_hash = serializable_hash_with_class_name(resource, 
-        class_name, options)
+    def serialize_and_flatten_collection(resource, class_name, options = {})
+      collection_option = collection?(true)
+      base_hash = serializable_hash_with_class_name(
+        resource,
+        class_name,
+        options.merge(collection_option),
+      )
       flatten_array_and_nest_data(base_hash, set_nested_option(options))
     end
+
+    alias_method :serializable, :serialize_and_flatten
+    alias_method :serializable_class, :serialize_and_flatten_with_class_name
+    alias_method :serializable_collection, :serialize_and_flatten_collection
   end
-end
+end

data/lib/lp/serializable/exceptions.rb

@@ -0,0 +1,11 @@
+module Lp
+  module Serializable
+    module Exceptions
+      class UnserializableCollection < StandardError
+        def initialize(msg = "Expected an object, but a collection was given.")
+          super
+        end
+      end
+    end
+  end
+end

data/lib/lp/serializable/strategies.rb

@@ -9,14 +9,14 @@ module Lp
 
       private
 
-      def serialize_hash(resource, options={})
-        "#{resource.class.name}Serializer"
-          .constantize.new(resource, options).serializable_hash
+      def serialize_hash(resource, options = {})
+        "#{resource.class.name}Serializer".
+          constantize.new(resource, options).serializable_hash
       end
 
-      def serializable_hash_with_class_name(resource, class_name, options={})
-        "#{class_name}Serializer"
-          .constantize.new(resource, options).serializable_hash
+      def serializable_hash_with_class_name(resource, class_name, options = {})
+        "#{class_name}Serializer".
+          constantize.new(resource, options).serializable_hash
       end
 
       def flatten_and_nest_data(hash, nested)
@@ -26,10 +26,14 @@ module Lp
       def flatten_array_and_nest_data(hash, nested)
         nest_data?(flatten_array_of_hashes(expose_data(hash)), nested)
       end
-      
+
+      def collection?(boolean)
+        { is_collection: boolean }
+      end
+
       def set_nested_option(options)
         options.fetch(:nested, false)
       end
     end
   end
-end
+end

data/lib/lp/serializable/utilities.rb

@@ -3,6 +3,8 @@ module Lp
     module Utilities
       private
 
+      REDUNDANT_KEYS = %i[attributes relationships].freeze
+
       def nest_data?(resource, nested)
         if nested
           resource
@@ -33,16 +35,31 @@ module Lp
 
       def flatten_hash(hash)
         return unless hash
-        hash.each_with_object({}) do |(k, v), h|
-          if v.is_a?(Hash) && k == :attributes
-            flatten_hash(v).map do |h_k, h_v|
-              h["#{h_k}".to_sym] = h_v
-            end
-          else 
-            h[k] = v
+        hash.each_with_object({}) do |(key, value), h|
+          if hash_and_matches_redundant_keys?(key, value)
+            flatten_hash_map(value, h)
+          elsif hash_and_has_data_key?(value)
+            h[key] = expose_data(value)
+          else
+            h[key] = value
           end
         end
       end
+
+      def flatten_hash_map(value, hash)
+        flatten_hash(value).map do |h_k, h_v|
+          hash[h_k.to_s.to_sym] = h_v
+        end
+      end
+
+      def hash_and_has_data_key?(value)
+        value.is_a?(Hash) && value.key?(:data)
+      end
+
+      # NOTE Supports native relationship references in serializer
+      def hash_and_matches_redundant_keys?(key, value)
+        value.is_a?(Hash) && REDUNDANT_KEYS.any? { |sym| sym == key }
+      end
     end
   end
-end
+end

data/lib/lp/serializable/version.rb

@@ -1,5 +1,5 @@
 module Lp
   module Serializable
-    VERSION = "0.1.0"
+    VERSION = "1.0.0"
   end
-end
+end

data/lp-serializable.gemspec

@@ -9,8 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["mrjonesbot"]
   spec.email         = ["nate@mrjones.io"]
 
-  spec.summary       = "Serialize with Fast JSON API, flatten like AWS"
-  # spec.description   = %q{TODO: Write a longer description or delete this line.}
+  spec.summary       = "Serialize with Fast JSON API, flatten like AMS"
+  spec.description   = "JSON API(jsonapi.org) serializer wrapper methods that work with Rails and can be used to serialize any kind of ruby object with AMS style output."
   spec.homepage      = "https://www.github.com/launchpadlab/lp-serializable"
   spec.license       = "MIT"
 
@@ -35,6 +35,15 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency "rake", "~> 10.0"
   spec.add_development_dependency "rspec", "~> 3.0"
   spec.add_development_dependency "pry"
+  spec.add_development_dependency(%q<activerecord>, [">= 4.2"])
+  spec.add_development_dependency(%q<active_model_serializers>, ["~> 0.10.7"])
+  spec.add_development_dependency(%q<jsonapi-rb>, ["~> 0.5.0"])
+  spec.add_development_dependency(%q<sqlite3>, ["~> 1.3"])
+  spec.add_development_dependency(%q<jsonapi-serializers>, ["~> 1.0.0"])
+  spec.add_development_dependency(%q<oj>, ["~> 3.3"])
+  spec.add_development_dependency(%q<rspec-benchmark>, ["~> 0.3.0"])
+  spec.add_runtime_dependency(%q<activesupport>, [">= 4.2"])
+  spec.add_development_dependency(%q<byebug>, [">= 0"])
 
-  spec.add_dependency "fast_jsonapi"
+  spec.add_dependency "fast_jsonapi", '>= 1.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lp-serializable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - mrjonesbot
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-09 00:00:00.000000000 Z
+date: 2020-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: appraisal
@@ -81,20 +81,147 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: fast_jsonapi
+  name: activerecord
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '4.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '4.2'
+- !ruby/object:Gem::Dependency
+  name: active_model_serializers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.10.7
+- !ruby/object:Gem::Dependency
+  name: jsonapi-rb
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.5.0
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: jsonapi-serializers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+- !ruby/object:Gem::Dependency
+  name: oj
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.3'
+- !ruby/object:Gem::Dependency
+  name: rspec-benchmark
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+- !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: 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'
-description: 
+- !ruby/object:Gem::Dependency
+  name: fast_jsonapi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: JSON API(jsonapi.org) serializer wrapper methods that work with Rails
+  and can be used to serialize any kind of ruby object with AMS style output.
 email:
 - nate@mrjones.io
 executables: []
@@ -103,6 +230,8 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".rubocop.yml"
+- ".ruby-version"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -112,7 +241,11 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- lib/fast_jsonapi/multi_to_json.rb
+- lib/fast_jsonapi/object_serializer.rb
+- lib/fast_jsonapi/serialization_core.rb
 - lib/lp/serializable.rb
+- lib/lp/serializable/exceptions.rb
 - lib/lp/serializable/strategies.rb
 - lib/lp/serializable/utilities.rb
 - lib/lp/serializable/version.rb
@@ -140,5 +273,5 @@ rubyforge_project:
 rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
-summary: Serialize with Fast JSON API, flatten like AWS
+summary: Serialize with Fast JSON API, flatten like AMS
 test_files: []