jsonapi_serializer 0.1.0

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/jsonapi_serializer.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'jsonapi_serializer/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "jsonapi_serializer"
+  spec.version       = JsonapiSerializer::VERSION
+  spec.authors       = ["Ivan Yurov"]
+  spec.email         = ["ivan.youroff@gmail.com"]
+
+  spec.summary       = %q{Alternative JSONApi serializer}
+  spec.description   = %q{Alternative JSONApi serializer inspired by Netflix's fast_jsonapi serializer}
+  spec.homepage      = "https://github.com/youroff/jsonapi_serializer"
+  spec.license       = "MIT"
+
+  spec.files = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency "activesupport", ">= 4.2"
+  spec.add_development_dependency "oj", "~> 3.3"
+  spec.add_development_dependency "multi_json", "~> 1.0"
+  spec.add_development_dependency "bundler", "~> 1.13"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "ffaker", "~> 2.8.1"
+  spec.add_development_dependency "fast_jsonapi", "~> 1.0"
+end

data/lib/jsonapi_serializer.rb

@@ -0,0 +1,56 @@
+require "active_support/inflector"
+require "jsonapi_serializer/version"
+require "jsonapi_serializer/aux/converters"
+require "jsonapi_serializer/base"
+require "jsonapi_serializer/polymorphic"
+
+module JsonapiSerializer
+  extend JsonapiSerializer::AUX::Converters
+
+  TRANSFORMS = {
+    dasherize: lambda { |str| str.to_s.underscore.dasherize.to_sym },
+    underscore: lambda { |str| str.to_s.underscore.to_sym },
+    camelize: lambda { |str| str.to_s.underscore.camelize(:lower).to_sym }
+  }
+
+  @@key_transform = TRANSFORMS[:underscore]
+  @@type_transform = TRANSFORMS[:underscore]
+  @@type_namespace_separator = "_"
+
+  def self.key_transform(key)
+    @@key_transform.call(key)
+  end
+
+  def self.type_transform(klass)
+    segments = klass.split("::").map { |segment| @@type_transform.call(segment) }
+    if @@type_namespace_separator == :ignore
+      segments.last
+    else
+      segments.join(@@type_namespace_separator)
+    end.to_sym
+  end
+
+  def self.set_key_transform(name = nil, &block)
+    if name.nil? && block_given?
+      @@key_transform = block
+    elsif name.is_a?(Symbol) && !block_given?
+      @@key_transform = TRANSFORMS[name]
+    else
+      raise ArgumentError, "set_key_transform accepts either a standard transform symbol (:dasherize, :underscore or :camelize) or a block"
+    end
+  end
+
+  def self.set_type_namespace_separator(separator)
+    @@type_namespace_separator = separator
+  end
+
+  def self.set_type_transform(name = nil, &block)
+    if name.nil? && block_given?
+      @@type_transform = block
+    elsif name.is_a?(Symbol) && !block_given?
+      @@type_transform = TRANSFORMS[name]
+    else
+      raise ArgumentError, "set_type_transform accepts either a standard transform symbol (:dasherize, :underscore or :camelize) or a block"
+    end
+  end
+end

data/lib/jsonapi_serializer/aux/converters.rb

@@ -0,0 +1,22 @@
+module JsonapiSerializer::AUX
+  module Converters
+
+    # http://jsonapi.org/format/#fetching-includes
+    # This method converts include string into hash accepted by serializer
+    def convert_include(include_string)
+      include_string.split(",").each_with_object({}) do |path, includes|
+        path.split(".").reduce(includes) do |ref, segment|
+          ref[segment.to_sym] ||= {}
+          ref[segment.to_sym]
+        end
+      end
+    end
+
+    # http://jsonapi.org/format/#fetching-sparse-fieldsets
+    def convert_fields(fields)
+      Hash[fields.map do |type, fields|
+        [type.to_sym, fields.split(",").map(&:to_sym)]
+      end]
+    end
+  end
+end

data/lib/jsonapi_serializer/base.rb

@@ -0,0 +1,105 @@
+require 'active_support/core_ext/object'
+require 'active_support/concern'
+require 'jsonapi_serializer/dsl/common'
+require 'jsonapi_serializer/utils'
+require 'jsonapi_serializer/common'
+require 'set'
+
+module JsonapiSerializer::Base
+  extend ActiveSupport::Concern
+  include JsonapiSerializer::DSL::Common
+  include JsonapiSerializer::Utils
+  include JsonapiSerializer::Common
+
+  def initialize(opts = {})
+    super(opts)
+    @id = self.class.meta_id
+    unless opts[:id_only]
+      @attributes = []
+      @relationships = []
+      @includes = normalize_includes(opts.fetch(:include, []))
+      prepare_fields(opts)
+      prepare_attributes
+      prepare_relationships
+    end
+  end
+
+  def id_hash(record)
+    {id: @id.call(record), type: @type}
+  end
+
+  def attributes_hash(record)
+    @attributes.each_with_object({}) do |(key, val), hash|
+      hash[key] = val.call(record)
+    end
+  end
+
+  def relationships_hash(record, context = {})
+    @relationships.each_with_object({}) do |(key, type, from, serializer), hash|
+      if rel = record.public_send(from)
+        if rel.respond_to?(:each)
+          hash[key] = {data: []}
+          rel.each do |item|
+            id = serializer.id_hash(item)
+            hash[key][:data] << id
+            add_included(serializer, item, id, context) if @includes.has_key?(key)
+          end
+        else
+          id = serializer.id_hash(rel)
+          hash[key] = {data: id}
+          add_included(serializer, rel, id, context) if @includes.has_key?(key)
+        end
+      else
+        hash[key] = {data: nil}
+      end
+    end
+  end
+
+  def record_hash(record, context = {})
+    hash = id_hash(record)
+    if context[:tracker]
+      (context[:tracker][hash[:type]] ||= Set.new).add?(hash[:id])
+    end
+    hash[:attributes] = attributes_hash(record) if @attributes.present?
+    hash[:relationships] = relationships_hash(record, context) if @relationships.present?
+    hash
+  end
+
+  private
+  def prepare_fields(opts)
+    @fields = opts.fetch(:fields, {})
+    if opts[:poly_fields].present? || @fields[@type].present?
+      @fields[@type] = opts.fetch(:poly_fields, []) + [*@fields.fetch(@type, [])].map { |f| JsonapiSerializer.key_transform(f) }
+      @fields[@type].uniq!
+    end
+  end
+
+  def prepare_attributes
+    key_intersect(@fields[@type], self.class.meta_attributes.keys).each do |key|
+      @attributes << [key, self.class.meta_attributes[key]]
+    end
+  end
+
+  def prepare_relationships
+    key_intersect(@fields[@type], self.class.meta_relationships.keys).each do |key|
+      rel = self.class.meta_relationships[key]
+      serializer = rel[:serializer].new(
+        fields: @fields,
+        include: @includes.fetch(key, []),
+        id_only: !@includes.has_key?(key)
+      )
+      @relationships << [key, rel[:type], rel[:from], serializer]
+    end
+  end
+
+  def add_included(serializer, item, id, context)
+    if (context[:tracker][id[:type]] ||= Set.new).add?(id[:id]).present?
+      attributes = serializer.attributes_hash(item)
+      relationships = serializer.relationships_hash(item, context)
+      inc = id.clone
+      inc[:attributes] = attributes if attributes.present?
+      inc[:relationships] = relationships if relationships.present?
+      context[:included] << inc
+    end
+  end
+end

data/lib/jsonapi_serializer/common.rb

@@ -0,0 +1,43 @@
+require 'active_support/core_ext/object'
+require 'active_support/concern'
+require 'multi_json'
+
+module JsonapiSerializer::Common
+  extend ActiveSupport::Concern
+
+  def initialize(opts = {})
+    @type = self.class.meta_type || guess_type
+  end
+
+  def type
+    @type
+  end
+
+  def serializable_hash(payload, opts = {})
+    hash = {}
+    context = {tracker: {}, included: []}
+
+    if payload.respond_to?(:map)
+      hash[:data] = payload.map { |p| record_hash(p, context) }
+    else
+      hash[:data] = record_hash(payload, context)
+    end
+
+    hash[:meta] = opts[:meta] if opts.has_key? :meta
+    hash[:included] = context[:included] if context[:included].present?
+    hash
+  end
+
+  def serialized_json(payload, opts = {})
+    MultiJson.dump(serializable_hash payload, opts)
+  end
+
+  private
+  def guess_type
+    if self.class.name.end_with?('Serializer')
+      JsonapiSerializer.type_transform(self.class.name.chomp('Serializer'))
+    else
+      raise "Serializer class must end with `Serializer` in order to be able to guess type"
+    end
+  end
+end

data/lib/jsonapi_serializer/dsl/common.rb

@@ -0,0 +1,77 @@
+require 'active_support/concern'
+require 'active_support/inflector'
+
+module JsonapiSerializer::DSL
+  module Common
+    extend ActiveSupport::Concern
+
+    included do
+      @meta_id = lambda { |obj| obj.id.to_s }
+      @meta_attributes = {}
+      @meta_relationships = {}
+
+      class << self
+        attr_reader :meta_type, :meta_id, :meta_attributes, :meta_relationships
+      end
+    end
+
+    class_methods do
+      def type(name)
+        @meta_type = name.to_sym
+      end
+
+      def id(attr = nil, &block)
+        case
+        when attr.nil? && block_given?
+          @meta_id = block
+        when attr.present? && !block_given?
+          @meta_id = lambda { |obj| obj.public_send(attr) }
+        else
+          raise ArgumentError, "ID hook requires either attribute name or block"
+        end
+      end
+
+      def attributes(*attrs)
+        attrs.each do |attr|
+          case attr
+          when Symbol, String
+            @meta_attributes[attr.to_sym] = lambda { |obj| obj.public_send(attr.to_sym) }
+          when Hash
+            attr.each do |key, val|
+              @meta_attributes[key] = lambda { |obj| obj.public_send(val) }
+            end
+          end
+        end
+      end
+
+      def attribute(attr, &block)
+        @meta_attributes[attr.to_sym] = block
+      end
+
+      def has_many(name, opts = {})
+        @meta_relationships[name] = {
+          type: :has_many,
+          from: opts.fetch(:from, name),
+          serializer: opts[:serializer] || guess_serializer(name.to_s.singularize)
+        }
+      end
+
+      def belongs_to(name, opts = {})
+        @meta_relationships[name] = {
+          type: :belongs_to,
+          from: opts.fetch(:from, name),
+          serializer: opts[:serializer] || guess_serializer(name.to_s)
+        }
+      end
+
+      def inherited(subclass)
+        raise "You attempted to inherit regular serializer class, if you want to create Polymorphic serializer, include Polymorphic mixin"
+      end
+
+      private
+      def guess_serializer(name)
+        "#{name.classify}Serializer".constantize
+      end
+    end
+  end
+end

data/lib/jsonapi_serializer/dsl/polymorphic.rb

@@ -0,0 +1,44 @@
+require 'active_support/concern'
+require 'jsonapi_serializer/dsl/common'
+
+module JsonapiSerializer::DSL
+  module Polymorphic
+    extend ActiveSupport::Concern
+    include JsonapiSerializer::DSL::Common
+
+    included do
+      @meta_poly = []
+      @meta_resolver = lambda { |record| JsonapiSerializer.type_transform(record.class.name) }
+
+      class << self
+        attr_reader :meta_poly, :meta_resolver, :meta_inherited
+      end
+    end
+
+    class_methods do
+      def resolver(&block)
+        if block_given?
+          @meta_resolver = block
+        else
+          raise ArgumentError, "Resolver hook requires a block that takes record and returns its type."
+        end
+      end
+
+      def polymorphic_for(*serializers)
+        @meta_poly += serializers
+      end
+
+      def inherited(subclass)
+        parent = self
+        subclass.class_eval do
+          include JsonapiSerializer::Base
+          @meta_attributes = parent.meta_attributes.clone
+          @meta_relationships = parent.meta_relationships.clone
+          @meta_id = parent.meta_id
+          @meta_inherited = true
+        end
+        @meta_poly << subclass
+      end
+    end
+  end
+end

data/lib/jsonapi_serializer/polymorphic.rb

@@ -0,0 +1,62 @@
+require 'active_support/core_ext/object'
+require 'active_support/concern'
+require 'multi_json'
+require 'jsonapi_serializer/dsl/polymorphic'
+require 'jsonapi_serializer/utils'
+require 'jsonapi_serializer/common'
+require 'set'
+
+module JsonapiSerializer::Polymorphic
+  extend ActiveSupport::Concern
+  include JsonapiSerializer::DSL::Polymorphic
+  include JsonapiSerializer::Utils
+  include JsonapiSerializer::Common
+
+  def initialize(opts = {})
+    super(opts)
+    unless self.class.meta_inherited
+      unless self.class.meta_resolver.respond_to? :call
+        raise "Polymorphic serializer must implement a block resolving an object into type."
+      end
+
+      poly_fields = [*opts.dig(:fields, @type)].map { |f| JsonapiSerializer.key_transform(f) }
+      if self.class.meta_poly.present?
+        @poly = self.class.meta_poly.each_with_object({}) do |poly_class, hash|
+          serializer = poly_class.new(opts.merge poly_fields: poly_fields)
+          hash[serializer.type] = serializer
+        end
+      else
+        raise "You have to create at least one children serializer for polymorphic #{self.class.name}"
+      end
+    end
+  end
+
+  def id_hash(record)
+    serializer_for(record).id_hash(record)
+  end
+
+  def attributes_hash(record)
+    serializer_for(record).attributes_hash(record)
+  end
+
+  def relationships_hash(record, context = {})
+    serializer_for(record).relationships_hash(record, context)
+  end
+
+  def record_hash(record, context = {})
+    hash = id_hash(record)
+
+    attributes = attributes_hash(record)
+    hash[:attributes] = attributes if attributes.present?
+
+    relationships = relationships_hash(record, context)
+    hash[:relationships] = relationships if relationships.present?
+
+    hash
+  end
+
+  private
+  def serializer_for(record)
+    @poly[self.class.meta_resolver.call(record)] || (raise "Could not resolve serializer for #{record} associated with #{self.class.name}")
+  end
+end