lp-serializable 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d1c00efce38a2b3b5333b36c47fd57256eef4caf70c4d873f4bc8483bbe64db
-  data.tar.gz: b54707da56b2e33bae82dd790ff8db046cce3ce4bc7c6ab44b176013a2c53699
+  metadata.gz: ee8c8007befe5042222082f7d355d28d8b5364d0a06499416055c7ff9c2ba24c
+  data.tar.gz: 9eeba9747a87355b25f45c013131374be16ff9c2f4a600c55efbf806f93148e1
 SHA512:
-  metadata.gz: 0c58d890a8aba1bdc6d8811db5fb68c04012d1a926d36c97748324e793afc451135d4b060d5e9300f5c8ec2cb8ca96a0256d4591275c2a88be5c482bbaf666c0
-  data.tar.gz: 6a8f7c983b80a7e8aa4a149750dfcc3198a4f0348b5ccad65c024dbcbfef788eb3cc7e511f3efdf71dbecee70372493e9b7da1c87b601bf60fad115341397781
+  metadata.gz: 8ec72124b13225234bfcdedb2663f52a5fa474ede7c4a526303d937098e60a1bd7c33342e2e0cfba9f805eb99d82171a9e6e08fb2820b428940ddb5c792febc8
+  data.tar.gz: 9d3899a92c259237da9bdca814bcc7ce00938764cd08ec889028466ec83100fba4e5ddd0a7fd9160aed2f4f788bc862ee1123270c9cdce0af7eab9e892485705

data/.ruby-version

@@ -0,0 +1 @@
+2.5.0

data/.travis.yml

@@ -3,3 +3,5 @@ language: ruby
 rvm:
   - 2.5.0
 before_install: gem install bundler -v 1.16.1
+ignore:
+  - spec/lib/object_serializer_performance.rb

data/Gemfile.lock

@@ -1,12 +1,37 @@
 PATH
   remote: .
   specs:
-    lp-serializable (0.1.0)
-      fast_jsonapi
+    lp-serializable (0.2.0)
+      activesupport (>= 4.2)
+      fast_jsonapi (>= 1.2)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    actionpack (5.2.0)
+      actionview (= 5.2.0)
+      activesupport (= 5.2.0)
+      rack (~> 2.0)
+      rack-test (>= 0.6.3)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.2)
+    actionview (5.2.0)
+      activesupport (= 5.2.0)
+      builder (~> 3.1)
+      erubi (~> 1.4)
+      rails-dom-testing (~> 2.0)
+      rails-html-sanitizer (~> 1.0, >= 1.0.3)
+    active_model_serializers (0.10.7)
+      actionpack (>= 4.1, < 6)
+      activemodel (>= 4.1, < 6)
+      case_transform (>= 0.2)
+      jsonapi-renderer (>= 0.1.1.beta1, < 0.3)
+    activemodel (5.2.0)
+      activesupport (= 5.2.0)
+    activerecord (5.2.0)
+      activemodel (= 5.2.0)
+      activesupport (= 5.2.0)
+      arel (>= 9.0)
     activesupport (5.2.0)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
@@ -16,23 +41,58 @@ GEM
       bundler
       rake
       thor (>= 0.14.0)
+    arel (9.0.0)
+    benchmark-perf (0.2.1)
+    builder (3.2.3)
+    byebug (10.0.2)
+    case_transform (0.2)
+      activesupport
     coderay (1.1.2)
     concurrent-ruby (1.0.5)
+    crass (1.0.4)
     diff-lcs (1.3)
+    erubi (1.7.1)
     fast_jsonapi (1.2)
       activesupport (>= 4.2)
     i18n (1.0.1)
       concurrent-ruby (~> 1.0)
+    jsonapi-deserializable (0.2.0)
+    jsonapi-rb (0.5.0)
+      jsonapi-deserializable (~> 0.2.0)
+      jsonapi-serializable (~> 0.3.0)
+    jsonapi-renderer (0.2.0)
+    jsonapi-serializable (0.3.0)
+      jsonapi-renderer (~> 0.2.0)
+    jsonapi-serializers (1.0.1)
+      activesupport
+    loofah (2.2.2)
+      crass (~> 1.0.2)
+      nokogiri (>= 1.5.9)
     method_source (0.9.0)
+    mini_portile2 (2.3.0)
     minitest (5.11.3)
+    nokogiri (1.8.4)
+      mini_portile2 (~> 2.3.0)
+    oj (3.6.3)
     pry (0.11.3)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
+    rack (2.0.5)
+    rack-test (1.0.0)
+      rack (>= 1.0, < 3)
+    rails-dom-testing (2.0.3)
+      activesupport (>= 4.2.0)
+      nokogiri (>= 1.6)
+    rails-html-sanitizer (1.0.4)
+      loofah (~> 2.2, >= 2.2.2)
     rake (10.5.0)
     rspec (3.7.0)
       rspec-core (~> 3.7.0)
       rspec-expectations (~> 3.7.0)
       rspec-mocks (~> 3.7.0)
+    rspec-benchmark (0.3.0)
+      benchmark-perf (~> 0.2.0)
+      rspec (>= 3.0.0, < 4.0.0)
     rspec-core (3.7.1)
       rspec-support (~> 3.7.0)
     rspec-expectations (3.7.0)
@@ -42,6 +102,7 @@ GEM
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.7.0)
     rspec-support (3.7.1)
+    sqlite3 (1.3.13)
     thor (0.20.0)
     thread_safe (0.3.6)
     tzinfo (1.2.5)
@@ -51,12 +112,20 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  active_model_serializers (~> 0.10.7)
+  activerecord (>= 4.2)
   appraisal
   bundler (~> 1.16)
+  byebug
+  jsonapi-rb (~> 0.5.0)
+  jsonapi-serializers (~> 1.0.0)
   lp-serializable!
+  oj (~> 3.3)
   pry
   rake (~> 10.0)
   rspec (~> 3.0)
+  rspec-benchmark (~> 0.3.0)
+  sqlite3 (~> 1.3)
 
 BUNDLED WITH
    1.16.1

data/README.md

@@ -1,8 +1,10 @@
 # Lp::Serializable
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/lp/serializable`. To experiment with that code, run `bin/console` for an interactive prompt.
+When serializing with [fast_jsonapi](https://github.com/Netflix/fast_jsonapi), data is structured per the json-api [specs](http://jsonapi.org/format/).
 
-TODO: Delete this and the text above, and describe your gem
+lp-serializable is a thin wrapper around fast_jsonapi serialization, producting AMS style output.
+
+lp-serializable is intended to be used in Rails controllers.
 
 ## Installation
 
@@ -22,7 +24,107 @@ Or install it yourself as:
 
 ## Usage
 
-TODO: Write usage instructions here
+### Controller Definition
+
+```ruby
+class ApplicationController < ActionController::Base
+    include Lp::Serializable
+end
+
+class MoviesController < ApplicationController
+    def index
+        movies = Movie.all
+        movies_hash = serialize_and_flatten_collection(movies, 'Movie')
+        render json: movies_hash
+    end
+
+    def show
+        movie = Movie.find(params[:id])
+        movie_hash = serialize_and_flatten(movie)
+        render json: movie
+    end
+end
+```
+
+### Serializer Definition
+
+```ruby
+class MovieSerializer
+    include FastJsonapi::ObjectSerializer
+
+    attributes :name, :year
+
+    has_many :actors
+    belongs_to :owner
+end
+
+class ActorSerializer
+    include FastJsonapi::ObjectSerializer
+    
+    attributes :id
+end
+
+class OwnerSerializer
+    include FastJsonapi::ObjectSerializer
+
+    attributes :id
+end
+```
+
+### Sample Object
+
+```ruby
+movie = Movie.new
+movie.id = 232
+movie.name = 'test movie'
+movie.actor_ids = [1, 2, 3]
+movie.owner_id = 3
+movie.movie_type_id = 1
+movie
+```
+
+### Object Serialization
+
+#### Return a hash
+```ruby
+hash = serialize_and_flatten(movie)
+```
+
+#### Output
+
+```json
+{
+  "data": {
+    "id": "3",
+    "type": "movie",
+    "name": "test movie",
+    "year": null,
+    "actors": [
+        {
+            "id": "1",
+            "type": "actor"
+        },
+        {
+            "id": "2",
+            "type": "actor"
+        }
+    ],
+    "owner": {
+        "id": "3",
+        "type": "user"
+    }
+  }
+}
+
+```
+
+For more information on configuration, refer to [fast_jsonapi](https://github.com/Netflix/fast_jsonapi#customizable-options) documentation.
+
+## Options Support
+
+lp-serializable does not currently support fast_jsonapi's options hash when instantiating serializers. 
+
+This affects serializing with [params](https://github.com/Netflix/fast_jsonapi#params), [compound documents](https://github.com/Netflix/fast_jsonapi#compound-document), metadata, and links.
 
 ## Development
 

data/lib/fast_jsonapi/multi_to_json.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+# Usage:
+#   class Movie
+#     def to_json(payload)
+#       FastJsonapi::MultiToJson.to_json(payload)
+#     end
+#   end
+module FastJsonapi
+  module MultiToJson
+    # Result object pattern is from https://johnnunemaker.com/resilience-in-ruby/
+    # e.g. https://github.com/github/github-ds/blob/fbda5389711edfb4c10b6c6bad19311dfcb1bac1/lib/github/result.rb
+    class Result
+      def initialize(*rescued_exceptions)
+        @rescued_exceptions = if rescued_exceptions.empty?
+          [StandardError]
+        else
+          rescued_exceptions
+        end
+
+        @value = yield
+        @error = nil
+      rescue *rescued_exceptions => e
+        @error = e
+      end
+
+      def ok?
+        @error.nil?
+      end
+
+      def value!
+        if ok?
+          @value
+        else
+          raise @error
+        end
+      end
+
+      def rescue
+        return self if ok?
+
+        Result.new(*@rescued_exceptions) { yield(@error) }
+      end
+    end
+
+    def self.logger(device=nil)
+      return @logger = Logger.new(device) if device
+      @logger ||= Logger.new(IO::NULL)
+    end
+
+    # Encoder-compatible with default MultiJSON adapters and defaults
+    def self.to_json_method
+      encode_method = String.new(%(def _fast_to_json(object)\n ))
+      encode_method << Result.new(LoadError) {
+        require 'oj'
+        %(::Oj.dump(object, mode: :compat, time_format: :ruby, use_to_json: true))
+      }.rescue {
+        require 'yajl'
+        %(::Yajl::Encoder.encode(object))
+      }.rescue {
+        require 'jrjackson' unless defined?(::JrJackson)
+        %(::JrJackson::Json.dump(object))
+      }.rescue {
+        require 'json'
+        %(JSON.fast_generate(object, create_additions: false, quirks_mode: true))
+      }.rescue {
+        require 'gson'
+        %(::Gson::Encoder.new({}).encode(object))
+      }.rescue {
+        require 'active_support/json/encoding'
+        %(::ActiveSupport::JSON.encode(object))
+      }.rescue {
+        warn "No JSON encoder found. Falling back to `object.to_json`"
+        %(object.to_json)
+      }.value!
+      encode_method << "\nend"
+    end
+
+    def self.to_json(object)
+      _fast_to_json(object)
+    rescue NameError
+      define_to_json(FastJsonapi::MultiToJson)
+      _fast_to_json(object)
+    end
+
+    def self.define_to_json(receiver)
+      cl = caller_locations[0]
+      method_body = to_json_method
+      logger.debug { "Defining #{receiver}._fast_to_json as #{method_body.inspect}" }
+      receiver.instance_eval method_body, cl.absolute_path, cl.lineno
+    end
+
+    def self.reset_to_json!
+      undef :_fast_to_json if method_defined?(:_fast_to_json)
+      logger.debug { "Undefining #{receiver}._fast_to_json" }
+    end
+  end
+end

data/lib/fast_jsonapi/object_serializer.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object'
+require 'active_support/concern'
+require 'active_support/inflector'
+require 'fast_jsonapi/serialization_core'
+
+module FastJsonapi
+  module ObjectSerializer
+    extend ActiveSupport::Concern
+    include SerializationCore
+
+    SERIALIZABLE_HASH_NOTIFICATION = 'render.fast_jsonapi.serializable_hash'
+    SERIALIZED_JSON_NOTIFICATION = 'render.fast_jsonapi.serialized_json'
+
+    included do
+      # Set record_type based on the name of the serializer class
+      set_type(reflected_record_type) if reflected_record_type
+    end
+
+    def initialize(resource, options = {})
+      process_options(options)
+
+      @resource = resource
+    end
+
+    def serializable_hash
+      return hash_for_collection if is_collection?(@resource)
+
+      hash_for_one_record
+    end
+    alias_method :to_hash, :serializable_hash
+
+    def hash_for_one_record
+      serializable_hash = { data: nil }
+      serializable_hash[:meta] = @meta if @meta.present?
+      serializable_hash[:links] = @links if @links.present?
+
+      return serializable_hash unless @resource
+
+      serializable_hash[:data] = self.class.record_hash(@resource, @params)
+      serializable_hash[:included] = self.class.get_included_records(@resource, @includes, @known_included_objects, @params) if @includes.present?
+      serializable_hash
+    end
+
+    def hash_for_collection
+      serializable_hash = {}
+
+      data = []
+      included = []
+      @resource.each do |record|
+        data << self.class.record_hash(record, @params)
+        included.concat self.class.get_included_records(record, @includes, @known_included_objects, @params) if @includes.present?
+      end
+
+      serializable_hash[:data] = data
+      serializable_hash[:included] = included if @includes.present?
+      serializable_hash[:meta] = @meta if @meta.present?
+      serializable_hash[:links] = @links if @links.present?
+      serializable_hash
+    end
+
+    def serialized_json
+      self.class.to_json(serializable_hash)
+    end
+
+    private
+
+    def process_options(options)
+      return if options.blank?
+
+      @known_included_objects = {}
+      @meta = options[:meta]
+      @links = options[:links]
+      @params = options[:params] || {}
+      raise ArgumentError.new("`params` option passed to serializer must be a hash") unless @params.is_a?(Hash)
+
+      if options[:include].present?
+        @includes = options[:include].delete_if(&:blank?).map(&:to_sym)
+        self.class.validate_includes!(@includes)
+      end
+    end
+
+    def is_collection?(resource)
+      resource.respond_to?(:each) && !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?
+        subclass.relationships_to_serialize = relationships_to_serialize.dup if relationships_to_serialize.present?
+        subclass.cachable_relationships_to_serialize = cachable_relationships_to_serialize.dup if cachable_relationships_to_serialize.present?
+        subclass.uncachable_relationships_to_serialize = uncachable_relationships_to_serialize.dup if uncachable_relationships_to_serialize.present?
+        subclass.transform_method = transform_method
+        subclass.cache_length = cache_length
+        subclass.race_condition_ttl = race_condition_ttl
+        subclass.data_links = data_links
+        subclass.cached = cached
+      end
+
+      def reflected_record_type
+        return @reflected_record_type if defined?(@reflected_record_type)
+
+        @reflected_record_type ||= begin
+          if self.name.end_with?('Serializer')
+            self.name.split('::').last.chomp('Serializer').underscore.to_sym
+          end
+        end
+      end
+
+      def set_key_transform(transform_name)
+        mapping = {
+          camel: :camelize,
+          camel_lower: [:camelize, :lower],
+          dash: :dasherize,
+          underscore: :underscore
+        }
+        self.transform_method = mapping[transform_name.to_sym]
+      end
+
+      def run_key_transform(input)
+        if self.transform_method.present?
+          input.to_s.send(*@transform_method).to_sym
+        else
+          input.to_sym
+        end
+      end
+
+      def use_hyphen
+        warn('DEPRECATION WARNING: use_hyphen is deprecated and will be removed from fast_jsonapi 2.0 use (set_key_transform :dash) instead')
+        set_key_transform :dash
+      end
+
+      def set_type(type_name)
+        self.record_type = run_key_transform(type_name)
+      end
+
+      def set_id(id_name)
+        self.record_id = id_name
+      end
+
+      def cache_options(cache_options)
+        self.cached = cache_options[:enabled] || false
+        self.cache_length = cache_options[:cache_length] || 5.minutes
+        self.race_condition_ttl = cache_options[:race_condition_ttl] || 5.seconds
+      end
+
+      def attributes(*attributes_list, &block)
+        attributes_list = attributes_list.first if attributes_list.first.class.is_a?(Array)
+        self.attributes_to_serialize = {} if self.attributes_to_serialize.nil?
+        attributes_list.each do |attr_name|
+          method_name = attr_name
+          key = run_key_transform(method_name)
+          attributes_to_serialize[key] = block || method_name
+        end
+      end
+
+      alias_method :attribute, :attributes
+
+      def add_relationship(name, relationship)
+        self.relationships_to_serialize = {} if relationships_to_serialize.nil?
+        self.cachable_relationships_to_serialize = {} if cachable_relationships_to_serialize.nil?
+        self.uncachable_relationships_to_serialize = {} if uncachable_relationships_to_serialize.nil?
+
+        if !relationship[:cached]
+          self.uncachable_relationships_to_serialize[name] = relationship
+        else
+          self.cachable_relationships_to_serialize[name] = relationship
+        end
+        self.relationships_to_serialize[name] = relationship
+     end
+
+      def has_many(relationship_name, options = {}, &block)
+        name = relationship_name.to_sym
+        hash = create_relationship_hash(relationship_name, :has_many, options, block)
+        add_relationship(name, hash)
+      end
+
+      def has_one(relationship_name, options = {}, &block)
+        name = relationship_name.to_sym
+        hash = create_relationship_hash(relationship_name, :has_one, options, block)
+        add_relationship(name, hash)
+      end
+
+      def belongs_to(relationship_name, options = {}, &block)
+        name = relationship_name.to_sym
+        hash = create_relationship_hash(relationship_name, :belongs_to, options, block)
+        add_relationship(name, hash)
+      end
+
+      def create_relationship_hash(base_key, relationship_type, options, block)
+        name = base_key.to_sym
+        if relationship_type == :has_many
+          base_serialization_key = base_key.to_s.singularize
+          base_key_sym = base_serialization_key.to_sym
+          id_postfix = '_ids'
+        else
+          base_serialization_key = base_key
+          base_key_sym = name
+          id_postfix = '_id'
+        end
+        {
+          key: options[:key] || run_key_transform(base_key),
+          name: name,
+          id_method_name: options[:id_method_name] || "#{base_serialization_key}#{id_postfix}".to_sym,
+          record_type: options[:record_type] || run_key_transform(base_key_sym),
+          object_method_name: options[:object_method_name] || name,
+          object_block: block,
+          serializer: compute_serializer_name(options[:serializer] || base_key_sym),
+          relationship_type: relationship_type,
+          cached: options[:cached] || false,
+          polymorphic: fetch_polymorphic_option(options)
+        }
+      end
+
+      def compute_serializer_name(serializer_key)
+        return serializer_key unless serializer_key.is_a? Symbol
+        namespace = self.name.gsub(/()?\w+Serializer$/, '')
+        serializer_name = serializer_key.to_s.classify + 'Serializer'
+        (namespace + serializer_name).to_sym
+      end
+
+      def fetch_polymorphic_option(options)
+        option = options[:polymorphic]
+        return false unless option.present?
+        return option if option.respond_to? :keys
+        {}
+      end
+
+      def link(link_name, link_method_name = nil, &block)
+        self.data_links = {} if self.data_links.nil?
+        link_method_name = link_name if link_method_name.nil?
+        key = run_key_transform(link_name)
+        self.data_links[key] = block || link_method_name
+      end
+
+      def validate_includes!(includes)
+        return if includes.blank?
+
+        includes.detect do |include_item|
+          klass = self
+          parse_include_item(include_item).each do |parsed_include|
+            relationship_to_include = klass.relationships_to_serialize[parsed_include]
+            raise ArgumentError, "#{parsed_include} is not specified as a relationship on #{klass.name}" unless relationship_to_include
+            raise NotImplementedError if relationship_to_include[:polymorphic].is_a?(Hash)
+            klass = relationship_to_include[:serializer].to_s.constantize
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fast_jsonapi/serialization_core.rb

@@ -0,0 +1,192 @@
+# 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_to_serialize.each_with_object({}) do |(key, method), attr_hash|
+          attr_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 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/utilities.rb

@@ -3,6 +3,8 @@ module Lp
     module Utilities
       private
 
+      REDUNDANT_KEYS = %i(attributes relationships)
+
       def nest_data?(resource, nested)
         if nested
           resource
@@ -34,15 +36,26 @@ module Lp
       def flatten_hash(hash)
         return unless hash
         hash.each_with_object({}) do |(k, v), h|
-          if v.is_a?(Hash) && k == :attributes
+          if hash_and_matches_redundant_keys?(v, k)
             flatten_hash(v).map do |h_k, h_v|
-              h["#{h_k}".to_sym] = h_v
+              h[h_k.to_s.to_sym] = h_v
             end
-          else 
+          # NOTE: extract this into a different method?
+          elsif hash_and_has_data_key?(v)
+            h[k] = expose_data(v)
+          else
             h[k] = v
           end
         end
       end
+
+      def hash_and_has_data_key?(value)
+        value.is_a?(Hash) && value.key?(:data)
+      end
+
+      def hash_and_matches_redundant_keys?(value, key)
+        value.is_a?(Hash) && REDUNDANT_KEYS.any?{|sym| sym == key}
+      end
     end
   end
 end

data/lib/lp/serializable/version.rb

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

data/lib/lp/serializable.rb

@@ -1,4 +1,3 @@
-require "lp/serializable/version"
 require "lp/serializable/strategies"
 
 module Lp
@@ -19,13 +18,15 @@ module Lp
     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)
+                                                    class_name, 
+                                                    options)
       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)
+                                                    class_name, 
+                                                    options)
       flatten_array_and_nest_data(base_hash, set_nested_option(options))
     end
   end

data/lp-serializable.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |spec|
   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.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"
-end
+  spec.add_dependency "fast_jsonapi", '>= 1.2'
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lp-serializable
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - mrjonesbot
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-07-09 00:00:00.000000000 Z
+date: 2018-07-14 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.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '1.2'
+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,7 @@ extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".ruby-version"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -112,6 +240,9 @@ 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/strategies.rb
 - lib/lp/serializable/utilities.rb