panko_serializer 0.1.8 → 0.1.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 390a6c3440b79ab3748f8a6f904de26f615bdfc7
-  data.tar.gz: 2c402a39f74eff6b0ae928c7fe31840c9c82ea66
+  metadata.gz: 9c6bed38967e51bd9b7902aa9b98378c47ed947e
+  data.tar.gz: a538bbe197fabf3220485e05c886a47d6cf22713
 SHA512:
-  metadata.gz: bb29ceacf15b3cf3d5dbcead7ca1c61ab758d3342e1af98323f1cee69cbc53e89375bc744cefdc77c5cf909f70b18ea2fe5523cd87ec4f8c02929a2a31d53cd6
-  data.tar.gz: f85fe9e539ce2c3e051c07139f01a3318f075102bb745cf809e31e0b75874e5af920f403dd834ad5eab0c8bc22cde77b39051bf85a0993546bd641f5c1062db2
+  metadata.gz: 16fb0300a61dfd66e5b364640846dd1bdb7944a707e44e904f043b332b0ab700d878de100f5828577fdc1acc1b7e0247411b99a770ca9f3aa0b7e90b6acd79d5
+  data.tar.gz: ec5ac08ac0c6b8f20c714d3cd2079667ef45bd0f332df9d3a2eb527221c0e147e8cc183ae972d9b7b8bff2518b6a384ed8df08e8874535e4f35b2db23f2f9c53

data/README.md

@@ -2,13 +2,103 @@
 
 [![Build Status](https://travis-ci.org/yosiat/panko_serializer.svg?branch=master)](https://travis-ci.org/yosiat/panko_serializer)
 
-Panko is high performance library for serializing ActiveRecord objects.
+Panko is library which is inspired by ActiveModelSerializers 0.9 for serializing ActiveRecord objects to JSON strings, fast.
 
-## Status
+To achieve it's performance:
 
-Panko is not ready for official release (it's missing documentation, tests, configuration options to remove assumptions).
+* Oj - Panko relies Oj since it's fast and allow to to serialize incrementally using `Oj::StringWriter`
+* Serialization Descriptor - Panko computes most of the metadata ahead of time, to save time later in serialization.
+* Type casting — Panko does type casting by it's self, instead of relying ActiveRecord.
 
+To dig deeper about the performance choices, read [Design Choices](https://github.com/yosiat/panko_serializer/wiki/Design-Choices).
 
+### Status
+
+Panko is not ready for official release - it's missing documentation, tests which all be done incrementally.
+If you want to start using Panko to see if it helps you, you are welcome! but check it well before deploying to Production.
+
+
+## Installation
+
+To install Panko, all you need is to add it to your Gemfile:
+
+```ruby
+gem "panko_serializer"
+```
+
+Then, install it on the command line:
+
+```
+> bundle install
+```
+
+> Since the Gem name and namespace differ, you need to require "panko" explicitly. This will be fixed before official release.
+
+
+
+## Usage
+
+### Getting Started
+
+Let's create serializer and use it inside Rails controller.
+
+```ruby
+class PostSerializer < Panko::Serializer
+  attributes :title
+end
+
+class UserSerializer < Panko::Serializer
+  attributes :id, :name, :age
+  
+  has_many :posts, serializer: PostSerializer
+end
+```
+
+As you can see, defining serializers is simple and resembles ActiveModelSerializers 0.9,
+To utilize the `UserSerializer` inside a Rails controller and serialize some users, all we need to do is:
+
+```ruby
+class UsersController < ApplicationController
+ def index
+   users = User.includes(:posts).all
+   render json: Panko::ArraySerializer(users, each_serializer: UserSerializer).to_json
+ end
+end
+```
+
+And voila, we have endpoint which serializers user records using Panko!
+
+
+## Features
+
+### Attributes
+
+Attributes allow you to specify which record attributes you want to serialize,
+There are two types of attributes:
+
+* Field - simple columns defined on the record it self.
+* Virtual/Method - this allows to include properties beyond simple fields.
+
+Example:
+
+```ruby
+class UserSerializer < Panko::Serializer
+ attributes :full_name
+ 
+ def full_name
+  "#{object.first_name} #{object.last_name}"
+ end
+end
+```
+
+As you can see, in order to access the serialized record, you need to access `object`.
+If you want to pass data to the serializer, beyond the serialized record, you can pass `context` to the serializer (both in single and array serializer).
+
+#### TODO:
+Finished feature, will add documentation sson:
+- Realtionships - `has_one`, `has_many`
+- Filters & Nested Filters
+- Reponse bag
 
 ## License
 The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/benchmarks/bm_serialization_descriptor.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+require_relative "./benchmarking_support"
+require "rails"
+require "active_model"
+require "active_support"
+require "active_support/json"
+require "action_controller"
+require "action_controller/railtie"
+
+
+require "memory_profiler"
+require "ruby-prof"
+require "ruby-prof-flamegraph"
+require "panko_serializer"
+
+def generate_attributes(count)
+  (1..count).map { |i| "attr_#{i}".to_sym }
+end
+
+class LeafASerializer < Panko::Serializer
+  attributes *generate_attributes(5)
+end
+
+class LeafBSerializer < Panko::Serializer
+  attributes *generate_attributes(6)
+end
+
+class ChildrenSerializer < Panko::Serializer
+  attributes *generate_attributes(28)
+
+  has_one :leaf_a, serializer: LeafASerializer
+  has_one :leaf_b, serializer: LeafBSerializer
+
+  def attr_1
+  end
+
+  def attr_2
+  end
+
+  def attr_3
+  end
+
+  def attr_4
+  end
+
+  def attr_5
+  end
+end
+
+class ParentSerializer < Panko::Serializer
+  attributes *generate_attributes(46)
+
+  has_many :children, serializer: ChildrenSerializer
+
+
+  def attr_1
+  end
+
+  def attr_2
+  end
+
+  def attr_3
+  end
+
+  def attr_4
+  end
+end
+
+attrs = generate_attributes(21)
+attrs << :children
+filters = {
+  instance: attrs,
+  children: generate_attributes(11)
+}
+Benchmark.run("NoFilters") do
+  Panko::SerializationDescriptor.build(ParentSerializer)
+end
+
+Benchmark.run("Attribute") do
+  Panko::SerializationDescriptor.build(ParentSerializer, only: [:children])
+end
+
+Benchmark.run("AssociationFilters") do
+  Panko::SerializationDescriptor.build(ParentSerializer, only: filters)
+end

data/ext/panko_serializer/panko_serializer.c

@@ -62,7 +62,7 @@ void serialize_fields(VALUE subject,
   serialize_method_fields(subject, str_writer, descriptor, context);
 }
 
-void serialize_has_one_associatoins(VALUE subject,
+void serialize_has_one_associations(VALUE subject,
                                     VALUE str_writer,
                                     VALUE context,
                                     SerializationDescriptor descriptor,
@@ -84,7 +84,7 @@ void serialize_has_one_associatoins(VALUE subject,
   }
 }
 
-void serialize_has_many_associatoins(VALUE subject,
+void serialize_has_many_associations(VALUE subject,
                                      VALUE str_writer,
                                      VALUE context,
                                      SerializationDescriptor descriptor,
@@ -116,12 +116,12 @@ VALUE serialize_subject(VALUE key,
   serialize_fields(subject, str_writer, descriptor, context);
 
   if (RARRAY_LEN(descriptor->has_one_associations) >= 0) {
-    serialize_has_one_associatoins(subject, str_writer, context, descriptor,
+    serialize_has_one_associations(subject, str_writer, context, descriptor,
                                    descriptor->has_one_associations);
   }
 
   if (RARRAY_LEN(descriptor->has_many_associations) >= 0) {
-    serialize_has_many_associatoins(subject, str_writer, context, descriptor,
+    serialize_has_many_associations(subject, str_writer, context, descriptor,
                                     descriptor->has_many_associations);
   }
 

data/lib/panko/serialization_descriptor.rb

@@ -35,6 +35,8 @@ module Panko
     # Applies attributes and association filters
     #
     def apply_filters(options)
+      return unless options.key?(:only) || options.key?(:except)
+
       attributes_only_filters, associations_only_filters = resolve_filters(options, :only)
       attributes_except_filters, associations_except_filters = resolve_filters(options, :except)
 
@@ -50,36 +52,57 @@ module Panko
         attributes_except_filters
       )
 
-      self.has_many_associations = apply_association_filters(
-        self.has_many_associations,
-        { attributes: attributes_only_filters, associations: associations_only_filters },
-        { attributes: attributes_except_filters, associations: associations_except_filters }
-      )
+      unless self.has_many_associations.empty?
+        self.has_many_associations = apply_association_filters(
+          self.has_many_associations,
+          { attributes: attributes_only_filters, associations: associations_only_filters },
+          { attributes: attributes_except_filters, associations: associations_except_filters }
+        )
+      end
 
-      self.has_one_associations = apply_association_filters(
-        self.has_one_associations,
-        { attributes: attributes_only_filters, associations: associations_only_filters },
-        { attributes: attributes_except_filters, associations: associations_except_filters }
-      )
+      unless self.has_one_associations.empty?
+        self.has_one_associations = apply_association_filters(
+          self.has_one_associations,
+          { attributes: attributes_only_filters, associations: associations_only_filters },
+          { attributes: attributes_except_filters, associations: associations_except_filters }
+        )
+      end
     end
 
     def apply_association_filters(associations, only_filters, except_filters)
-      attributes_only_filters = only_filters[:attributes]
-      attributes_only_filters = associations.map(&:first) if attributes_only_filters.empty?
+      attributes_only_filters = only_filters[:attributes] || []
+      unless attributes_only_filters.empty?
+        associations.select! do |association|
+          attributes_only_filters.include?(association.first)
+        end
+      end
+
       attributes_except_filters = except_filters[:attributes] || []
+      unless attributes_except_filters.empty?
+        associations.reject! do |association|
+          attributes_except_filters.include?(association.first)
+        end
+      end
+
+      associations_only_filters = only_filters[:associations]
+      associations_except_filters = except_filters[:associations]
 
+      if associations_only_filters.empty? && associations_except_filters.empty?
+        return associations
+      end
 
       associations.map do |association|
         name = association.first
-        next if attributes_except_filters.include? name
-        next unless attributes_only_filters.include? name
-
         descriptor = association.last
 
-        descriptor.apply_filters({
-          only: only_filters[:associations].fetch(name, []),
-          except: except_filters[:associations].fetch(name, [])
-        })
+        only_filter = associations_only_filters[name]
+        except_filter = associations_except_filters[name]
+
+        filters = {}
+        filters[:only] = only_filter unless only_filter.nil?
+        filters[:except] = except_filter unless except_filter.nil?
+
+        descriptor.apply_filters(filters) unless filters.empty?
 
         association
       end.compact

data/lib/panko/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module Panko
-  VERSION = "0.1.8"
+  VERSION = "0.1.9"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: panko_serializer
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.9
 platform: ruby
 authors:
 - Yosi Attias
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-09-29 00:00:00.000000000 Z
+date: 2017-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -105,6 +105,7 @@ files:
 - benchmarks/bm_controller.rb
 - benchmarks/bm_panko_json.rb
 - benchmarks/bm_panko_object.rb
+- benchmarks/bm_serialization_descriptor.rb
 - benchmarks/profile.rb
 - benchmarks/sanity.rb
 - benchmarks/setup.rb