primalize-jsonapi 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3350f0fd1aad3c862179c3a156a3d664bcf178d2e03205a67c77c735f9537fd5
-  data.tar.gz: 61448a12418885035336205324c3755a9556d25d60a7f9cfc332b02ab9fcaab2
+  metadata.gz: 3392a354c12975c1f43bdc043afcbae8a7596289f4705c07ce12f39c287cf8cd
+  data.tar.gz: '097d8258d2137658be6f994732b35e0cd57848481a369bf1bb5bee31ac2ee084'
 SHA512:
-  metadata.gz: 1066244c0722528c54ac831365f11f9711a8ad9e45102d11e237c0530848b8fb2fddffc1a5da592bf8a86080ebc4829215c3aec71a93c7d798c0172f0aab836e
-  data.tar.gz: 4f9821abd4eb1c960136298faf5a33e88a892a6e54a9b6edfd41e07b827a1ca8413d66736a343b4ae4d9909d7064e35b736afafc3f1bdef6789a2e7707f2b62b
+  metadata.gz: 0ad30361cccc42f2210e46e28aaec79b9a0624c23625b17aee02d5726b3842a2dec16e994df89cd5eb72fca29d0089d2230ce705a822d80f64c413af5d64cfec
+  data.tar.gz: 50c36d15c05656c64c3cc4f9c3163432c7c7479fb93b2581ced4529c1abe1865d1cf619cf4982f236e8315930c7420d8336dc930b2fb0de0ce47735fed4b382b

data/lib/primalize/jsonapi.rb

@@ -1,9 +1,34 @@
 require 'primalize/jsonapi/version'
 require 'primalize/single'
-require 'primalize/many'
 
 module Primalize
   module JSONAPI
+    @model_type_cache = {}
+    @serializer_map = {}
+
+    def self.serialize include: [], **models
+      if models.one?
+        type = models.each_key.first
+        cache = Cache.new
+        Array(models[type])
+          .map { |model| self[type].new(model, include: include, cache: cache).call }
+          .reduce({ data: [] }) { |result, hash|
+            result.merge!(hash) do |key, left, right|
+              case key
+              when :data
+                left + right
+              when :included
+                (left + right).tap(&:uniq!)
+              else
+                left.merge!(right)
+              end
+            end
+          }
+      else
+        raise ArgumentError, "cannot supply more than one resource type"
+      end
+    end
+
     class Relationships
       def initialize
         @rels = []
@@ -34,9 +59,9 @@ module Primalize
 
     class HasMany
       attr_reader :attr
-      def initialize attr, &block
+      def initialize attr, type: attr, &block
         @attr = attr
-        @block = block
+        @block = block || proc { JSONAPI.fetch(type) }
       end
 
       def call(model, cache:)
@@ -54,7 +79,7 @@ module Primalize
       def metadata(model, cache:)
         result = model.send(@attr).map do |obj|
           cache.fetch(:metadata, obj) do
-            MetadataPrimalizer.new(obj).call
+            MetadataPrimalizer.new(obj, primalizer.type).call
           end
         end
 
@@ -64,9 +89,9 @@ module Primalize
 
     class HasOne
       attr_reader :attr
-      def initialize attr, &block
+      def initialize attr, type: attr, &block
         @attr = attr
-        @block = block
+        @block = block || proc { JSONAPI.fetch(type) }
       end
 
       def call(model, cache:)
@@ -82,17 +107,22 @@ module Primalize
 
       def metadata(model, cache:)
         model = model.send(@attr)
-        cache.fetch(:metadata, model) do
-          { data: MetadataPrimalizer.new(model).call }
+        data = cache.fetch(:metadata, model) do
+          MetadataPrimalizer.new(model, primalizer.type).call
         end
+
+        { data: data }
       end
     end
 
     class MetadataPrimalizer < Single
       attributes(id: string(&:to_s), type: string)
 
-      def type
-        object.class.name.gsub(/(.)([A-Z])/, '\1_\2').downcase
+      attr_reader :type
+
+      def initialize model, type
+        super model
+        @type = type.to_s
       end
     end
 
@@ -107,40 +137,51 @@ module Primalize
       end
 
       def [] type, model
+        return if model.nil?
+
         @cache[type][model.class][model.id]
       end
 
       def []= type, model, value
+        return if model.nil?
+
         @cache[type][model.class][model.id] = value
       end
 
       def fetch type, model
+        return if model.nil?
+
         @cache[type][model.class][model.id] ||= yield
       end
     end
 
-    @serializer_map = {}
+    def self.[]= type, serializer
+      @serializer_map[type] = serializer
+    end
 
-    def self.[]= model_class, serializer
-      @serializer_map[model_class] = serializer
+    def self.fetch type
+      @serializer_map.fetch type do
+        raise ArgumentError,
+          "No Primalize::JSONAPI primalizer defined for #{type.inspect}"
+      end
     end
 
-    def self.[] model_class=nil, **options
-      @serializer_map[model_class] ||= Class.new(Single) do
-        @model_class = model_class
+    def self.[] type=nil, **options
+      @serializer_map[type] ||= Class.new(Single) do
+        @_type = type
 
         # This is useful for situations like this:
-        #   class MySerializer < Primalize::JSONAPI[MyModel]
+        #   class MySerializer < Primalize::JSONAPI[:movies]
         #   end
         define_singleton_method :inherited do |inheriting_class|
-          JSONAPI[model_class] = inheriting_class
+          JSONAPI[type] = inheriting_class
         end
 
-        def self.model_class
-          if @model_class
-            @model_class
+        def self.type
+          if @_type
+            @_type
           else
-            superclass.model_class
+            superclass.type
           end
         end
 
@@ -159,6 +200,25 @@ module Primalize
 
             define_singleton_method :attribute_primalizer do
               @attribute_primalizer ||= Class.new(Single) do
+                def initialize model, original:
+                  super model
+                  @original = original
+                end
+
+                def self.attributes(**attrs)
+                  super
+
+                  attrs.each do |attr, type|
+                    define_method attr do
+                      if @original.respond_to? attr
+                        @original.class.new(object).public_send attr
+                      else
+                        object.public_send attr
+                      end
+                    end
+                  end
+                end
+
                 define_singleton_method :to_s do
                   "#{original_primalizer}.model_primalizer.attribute_primalizer"
                 end
@@ -183,26 +243,28 @@ module Primalize
               id: string(&:to_s),
               type: string,
               attributes: object,
-              relationships: object,
+              relationships: optional(object),
             )
 
             attr_reader :cache
 
-            def initialize model, cache: Cache.new
-              super(model)
+            def initialize model, original:, include: [], cache: Cache.new
+              super model
+              @original = original
+              @include = include
               @cache = cache
             end
 
-            def self.name
-              'ModelPrimalizer'
+            define_method :type do
+              original_primalizer.type.to_s
             end
 
-            def type
-              object.class.name.gsub(/(.)([A-Z])/, '\1_\2').downcase
+            def attributes
+              self.class.attribute_primalizer.new(object, original: @original).call
             end
 
-            def attributes
-              self.class.attribute_primalizer.new(object).call
+            def call
+              super.tap(&:compact!)
             end
 
             def relationships
@@ -228,7 +290,7 @@ module Primalize
         attr_reader :cache
 
         def initialize models, include: [], meta: nil, cache: Cache.new
-          super Array(models)
+          super models
 
           @include = include
           @meta = meta
@@ -245,7 +307,7 @@ module Primalize
               included = Set.new
 
               @include.each do |rel|
-                object.each do |model|
+                Array(object).each do |model|
                   primalizer = self.class.model_primalizer.relationships[rel]
                   relationship = primalizer.call(model, cache: cache)
 
@@ -271,8 +333,8 @@ module Primalize
         end
 
         def data
-          object.map do |model|
-            self.class.model_primalizer.new(model, cache: cache).call
+          Array(object).map do |model|
+            self.class.model_primalizer.new(model, original: self, include: @include, cache: cache).call
           end
         end
       end

data/lib/primalize/jsonapi/version.rb

@@ -1,5 +1,5 @@
 module Primalize
   module JSONAPI
-    VERSION = "0.1.4"
+    VERSION = "0.1.5"
   end
 end

data/performance/benchmark.rb

@@ -0,0 +1,428 @@
+require 'benchmark/ips'
+$:.unshift 'lib'
+$:.unshift '../active_model_serializers/lib'
+require 'active_model_serializers'
+require 'primalize/jsonapi'
+require 'grand_central/model'
+require 'ffaker'
+require 'securerandom'
+
+class Model < GrandCentral::Model
+  def read_attribute_for_serialization attr
+    public_send attr
+  end
+end
+
+class Article < Model
+  attributes :id, :title, :body, :view_count, :author, :comments
+
+  def author_id(*args)
+    author&.id
+  end
+
+  def comment_ids
+    comments.map(&:id)
+  end
+end
+
+class Person < Model
+  attributes :id, :name, :email
+end
+
+class Comment < Model
+  attributes :id, :body, :author
+end
+
+class ArticlePrimalizer < Primalize::JSONAPI[:articles]
+  attributes(
+    title: string,
+    body: string,
+    view_count: integer,
+  )
+
+  has_one :author, type: :people
+  has_many :comments
+end
+
+class PersonPrimalizer < Primalize::JSONAPI[:people]
+  attributes(
+    name: string,
+    email: string,
+  )
+end
+
+class CommentPrimalizer < Primalize::JSONAPI[:comments]
+  attributes(
+    body: string,
+    author_name: string,
+  )
+  alias comment object
+
+  def author_name
+    comment.author.name
+  end
+end
+
+ActiveModel::Serializer.config.adapter = :json_api
+ActiveModel::Serializer.config.key_transform = :underscore
+ActiveModelSerializers.logger = ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new('/dev/null'))
+
+class ArticleSerializer < ActiveModel::Serializer
+  attributes :title, :body, :view_count
+
+  belongs_to :author
+  has_many :comments
+end
+
+class PersonSerializer < ActiveModel::Serializer
+  attributes :name, :email
+end
+
+class CommentSerializer < ActiveModel::Serializer
+  attributes :body, :author_name
+
+  def author_name
+    object.author.name
+  end
+end
+
+require 'fast_jsonapi'
+module Netflix
+  class ArticleSerializer
+    include FastJsonapi::ObjectSerializer
+
+    set_type :articles
+
+    attributes :title, :body, :view_count
+
+    belongs_to :author
+    has_many :comments
+  end
+
+  class PersonSerializer
+    include FastJsonapi::ObjectSerializer
+
+    set_type :people
+
+    attributes :name, :email
+  end
+  AuthorSerializer = PersonSerializer
+
+  class CommentSerializer
+    include FastJsonapi::ObjectSerializer
+
+    set_type :comments
+
+    attributes :body
+    attribute :author_name do |comment|
+      comment.author.name
+    end
+  end
+end
+
+require 'primalize'
+# require 'oj'
+module Response
+  class ArticlePrimalizer < Primalize::Single
+    attributes(
+      id: integer,
+      title: string,
+      body: string,
+      view_count: integer,
+      author_id: integer,
+      comment_ids: array(integer),
+    )
+    alias article object
+
+    def author_id
+      article.author.id
+    end
+
+    def comment_ids
+      article.comments.map(&:id)
+    end
+  end
+
+  class PersonPrimalizer < Primalize::Single
+    attributes(
+      id: integer,
+      name: string,
+      email: string,
+    )
+  end
+
+  class CommentPrimalizer < Primalize::Single
+    attributes(
+      id: integer,
+      body: string,
+      author_name: string,
+    )
+    alias comment object
+
+    def author_name
+      comment.author.name
+    end
+  end
+
+  class Response < Primalize::Many
+    # def to_json
+    #   Oj.dump call, mode: :json
+    # end
+  end
+
+  class ArticlesResponse < Response
+    attributes(
+      articles: enumerable(ArticlePrimalizer),
+    )
+  end
+
+  class ArticlesResponseWithAssociations < ArticlesResponse
+    attributes(
+      authors: enumerable(PersonPrimalizer),
+      comments: enumerable(CommentPrimalizer),
+    )
+
+    def initialize articles:, authors: articles.flat_map(&:author).uniq, comments: articles.flat_map(&:comments)
+      super(
+        articles: articles,
+        authors: authors,
+        comments: comments,
+      )
+    end
+  end
+
+  class ArticleResponse < Primalize::Many
+    attributes(
+      article: ArticlePrimalizer,
+    )
+  end
+
+  class ArticleResponseWithAssociations < ArticleResponse
+    attributes(
+      author: PersonPrimalizer,
+      comments: enumerable(CommentPrimalizer),
+    )
+
+    def initialize article:, author: article.author, comments: article.comments
+      super(
+        article: article,
+        author: author,
+        comments: comments,
+      )
+    end
+  end
+end
+
+people = Array.new(10) do |i|
+  Person.new(
+    id: i,
+    name: FFaker::Name.name,
+    email: FFaker::Internet.email,
+  )
+end
+comment_id = 0
+articles = Array.new(25) do |i|
+  Article.new(
+    id: i,
+    title: 'Foo',
+    body: 'Lorem ipsum dolor sit amet omg lol wtf bbq lmao rofl',
+    view_count: 12,
+    author: people.sample,
+    comments: Array.new(SecureRandom.random_number(0..10)) do
+      Comment.new(
+        id: comment_id += 1,
+        body: 'lol this is a comment and i am writing it',
+        author: people.sample,
+      )
+    end,
+  )
+end
+article = articles.first
+
+primalized = ArticlePrimalizer.new(articles, include: %i(author comments)).call.tap { |hash| hash[:included].sort_by! { |id:, type:, **| [type, id] } }
+ams = ActiveModelSerializers::SerializableResource.new(articles, include: %i(author comments).join(',')).as_json.tap { |hash| hash[:included].sort_by! { |id:, type:, **| [type, id] } }
+
+pp(
+  single_no_associations: pp(Primalize::JSONAPI.serialize(articles: article)) == pp(ActiveModelSerializers::SerializableResource.new([article]).as_json),
+  multi_no_associations: Primalize::JSONAPI.serialize(articles: articles) == ActiveModelSerializers::SerializableResource.new(articles).as_json,
+  single_with_associations: Primalize::JSONAPI.serialize(
+    articles: article,
+    include: %i(author comments),
+  ) == ActiveModelSerializers::SerializableResource.new(
+    [article],
+    include: %i(author comments),
+  ).as_json,
+  multi_with_associations: primalized == ams,
+)
+
+pp Response::ArticlesResponse.new(articles: articles).call
+require 'pry'
+binding.pry
+
+puts 'SINGLE OBJECT, NO ASSOCIATIONS, TO HASH'
+Benchmark.ips do |x|
+  x.report 'Primalize::JSONAPI' do
+    ArticlePrimalizer.new(article).call
+  end
+
+  x.report 'AMS' do
+    ActiveModelSerializers::SerializableResource.new(article).as_json
+  end
+
+  x.report 'FastJsonapi' do
+    Netflix::ArticleSerializer.new(article).as_json
+  end
+
+  x.report 'Primalize::Many' do
+    Response::ArticleResponse.new(article: article).call
+  end
+
+  x.compare!
+end
+
+puts 'SINGLE OBJECT, W/ ASSOCIATIONS, TO HASH'
+Benchmark.ips do |x|
+  x.report 'Primalize::JSONAPI' do
+    ArticlePrimalizer.new(article, include: %i(author comments)).call
+  end
+
+  x.report 'AMS' do
+    ActiveModelSerializers::SerializableResource.new(article, include: %i(author comments)).as_json
+  end
+
+  x.report 'FastJsonapi' do
+    Netflix::ArticleSerializer.new(article, include: %w(author comments)).as_json
+  end
+
+  x.report 'Primalize::Many' do
+    Response::ArticleResponseWithAssociations.new(article: article).call
+  end
+
+  x.compare!
+end
+
+puts 'MULTIPLE OBJECTS, NO ASSOCIATIONS, TO HASH'
+Benchmark.ips do |x|
+  x.report 'Primalize::JSONAPI' do
+    ArticlePrimalizer.new(articles).call
+  end
+
+  x.report 'AMS' do
+    ActiveModelSerializers::SerializableResource.new(articles).as_json
+  end
+
+  x.report 'FastJsonapi' do
+    Netflix::ArticleSerializer.new(articles).as_json
+  end
+
+  x.report 'Primalize::Many' do
+    Response::ArticlesResponse.new(articles: articles).call
+  end
+
+  x.compare!
+end
+
+puts 'MULTIPLE OBJECTS, W/ ASSOCIATIONS, TO HASH'
+Benchmark.ips do |x|
+  x.report 'Primalize::JSONAPI' do
+    Primalize::JSONAPI.serialize(articles: articles, include: %i(author comments))
+  end
+
+  x.report 'AMS' do
+    ActiveModelSerializers::SerializableResource.new(articles, include: %i(author comments)).as_json
+  end
+
+  x.report 'FastJsonapi' do
+    Netflix::ArticleSerializer.new(articles, include: %i(author comments)).as_json
+  end
+
+  x.report 'Primalize::Many' do
+    Response::ArticlesResponseWithAssociations.new(articles: articles).call
+  end
+
+  x.compare!
+end
+
+puts 'SINGLE OBJECT, NO ASSOCIATIONS, TO STRING'
+Benchmark.ips do |x|
+  x.report 'Primalize::JSONAPI' do
+    ArticlePrimalizer.new(article).to_json
+  end
+
+  x.report 'AMS' do
+    ActiveModelSerializers::SerializableResource.new(article).to_json
+  end
+
+  x.report 'FastJsonapi' do
+    Netflix::ArticleSerializer.new(article).to_json
+  end
+
+  x.report 'Primalize::Many' do
+    Response::ArticleResponse.new(article: article).to_json
+  end
+
+  x.compare!
+end
+
+puts 'SINGLE OBJECT, W/ ASSOCIATIONS, TO STRING'
+Benchmark.ips do |x|
+  x.report 'Primalize::JSONAPI' do
+    ArticlePrimalizer.new(article, include: %i(author comments)).to_json
+  end
+
+  x.report 'AMS' do
+    ActiveModelSerializers::SerializableResource.new(article, include: %i(author comments)).to_json
+  end
+
+  x.report 'FastJsonapi' do
+    Netflix::ArticleSerializer.new(article, include: %i(author comments)).to_json
+  end
+
+  x.report 'Primalize::Many' do
+    Response::ArticleResponseWithAssociations.new(article: article).to_json
+  end
+
+  x.compare!
+end
+
+puts 'MULTIPLE OBJECTS, NO ASSOCIATIONS, TO STRING'
+Benchmark.ips do |x|
+  x.report 'Primalize::JSONAPI' do
+    ArticlePrimalizer.new(articles).to_json
+  end
+
+  x.report 'AMS' do
+    ActiveModelSerializers::SerializableResource.new(articles).to_json
+  end
+
+  x.report 'FastJsonapi' do
+    Netflix::ArticleSerializer.new(articles).to_json
+  end
+
+  x.report 'Primalize::Many' do
+    Response::ArticlesResponse.new(articles: articles).to_json
+  end
+
+  x.compare!
+end
+
+puts 'MULTIPLE OBJECTS, W/ ASSOCIATIONS, TO STRING'
+Benchmark.ips do |x|
+  x.report 'Primalize::JSONAPI' do
+    Primalize::JSONAPI.serialize(articles: articles, include: %i(author comments)).to_json
+  end
+
+  x.report 'AMS' do
+    ActiveModelSerializers::SerializableResource.new(articles, include: %i(author comments)).to_json
+  end
+
+  x.report 'FastJsonapi' do
+    Netflix::ArticleSerializer.new(articles, include: %w(author comments)).to_json
+  end
+
+  x.report 'Primalize::Many' do
+    Response::ArticlesResponseWithAssociations.new(articles: articles).to_json
+  end
+
+  x.compare!
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: primalize-jsonapi
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Jamie Gaskins
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-11 00:00:00.000000000 Z
+date: 2018-06-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: primalize
@@ -113,6 +113,7 @@ files:
 - bin/setup
 - lib/primalize/jsonapi.rb
 - lib/primalize/jsonapi/version.rb
+- performance/benchmark.rb
 - primalize-jsonapi.gemspec
 homepage: https://github.com/jgaskins/primalize-jsonapi
 licenses:
@@ -134,7 +135,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.3
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: JSON API support for the Primalize gem