panko_serializer 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: e9e1120b6231ae836d11ca59c17443518f5ccb80
-  data.tar.gz: 2b38dd527027204628714825d38d5f8c83b0d4a9
+SHA256:
+  metadata.gz: eef3c77d8a03018af85326b4c07890d6d543909925c664f6baf6f20f634033e2
+  data.tar.gz: 28c88dea3cd021f1ba3cb5e31b21e03f3ddb9cdbf4851cccafa78770d742a994
 SHA512:
-  metadata.gz: 9642ae4e418b15a0051d2bb08b352bb035afabfb3f0eb115ded715fb6edc5db91a3a17a4dbd76793607b3c6db020eb2ea08625bf11e5b85311835cb8eebb428d
-  data.tar.gz: 9b0225b6e43c743425b8cbb0e105541ec646aa50a7fcaf634631ddc427ecc808cf1f96ac3a3ebe96bccdff292708f9a473f16be8481e4959917b79fc9b95d985
+  metadata.gz: edbe1e16a0216d8cd9e8af32289e6b173565ad7d1b50c3177f90a2cc683fd00d26cf7248e0d563e4a76916e481d0723b23041fe6973c5df05b180227e1da82fe
+  data.tar.gz: d0883a7ba84ff19d57738d56846ca9fc9b4ed70d6343c6280225ccfa83abe6489d611b64cea4be294ce4ddccfc8e992be55545fd6ff18bf65936fae91db94ce3

data/.gitignore

@@ -8,6 +8,10 @@
 /spec/reports/
 /tmp/
 /vendor/bundle/
+.byebug_history
+*.bundle
 
 # rspec failure tracking
 .rspec_status
+_docpress
+node_modules

data/.travis.yml

@@ -3,9 +3,22 @@ cache: bundler
 language: ruby
 rvm:
   - 2.4.2
+
+env:
+  global:
+    - GIT_NAME: Travis CI
+    - GIT_EMAIL: nobody@nobody.org
+
 install: bundle install --path=vendor/bundle --retry=3 --jobs=3
-before_install: gem install bundler
-after_success: bundle exec rake benchmarks
+
+before_install:
+  - gem install bundler
+  - nvm install 9
+
+after_success:
+  - npm install docpress && $(npm bin)/docpress build
+  - if [ -n "$TRAVIS_TAG" -a "$TRAVIS_PULL_REQUEST" = "false" ]; then npm install git-update-ghpages && $(npm bin)/git-update-ghpages yosiat/panko_serializer _docpress; fi
+  - bundle exec rake benchmarks
 
 env:
   matrix:

data/README.md

@@ -4,101 +4,24 @@
 
 Panko is library which is inspired by ActiveModelSerializers 0.9 for serializing ActiveRecord objects to JSON strings, fast.
 
-To achieve it's performance:
+To achieve it's [performance](https://yosiat.github.io/panko_serializer/performance.html):
 
 * 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).
+To dig deeper about the performance choices, read [Design Choices](https://yosiat.github.io/panko_serializer/design-choices.html).
 
-### 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.
+Support
+-------
 
+- [Documentation](https://yosiat.github.io/panko_serializer)
+- [Getting Started](https://yosiat.github.io/panko_serializer/getting-started.html)
+- Join our [slack community](https://pankoserializer.herokuapp.com/)
 
-## Installation
+License
+-------
 
-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
-```
-
-
-
-## 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 serialize users 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_active_model_serializers.rb

@@ -8,7 +8,7 @@ class AmsAuthorFastSerializer < ActiveModel::Serializer
 end
 
 class AmsPostFastSerializer < ActiveModel::Serializer
-  attributes :id, :body, :title, :author_id
+  attributes :id, :body, :title, :author_id, :created_at
 end
 
 class AmsPostWithHasOneFastSerializer < ActiveModel::Serializer
@@ -39,7 +39,7 @@ def benchmark_ams(prefix, serializer, options = {})
 end
 
 
-benchmark_ams "HasOne", AmsPostWithHasOneFastSerializer
 benchmark_ams "Simple", AmsPostFastSerializer
+benchmark_ams "HasOne", AmsPostWithHasOneFastSerializer
 benchmark_ams "Except", AmsPostWithHasOneFastSerializer, except: [:title]
 benchmark_ams "Include", AmsPostWithHasOneFastSerializer, include: [:id, :body, :author_id, :author]

data/benchmarks/bm_panko_json.rb

@@ -9,7 +9,7 @@ end
 
 
 class PostFastSerializer < Panko::Serializer
-  attributes :id, :body, :title, :author_id
+  attributes :id, :body, :title, :author_id, :created_at
 end
 
 class PostFastWithMethodCallSerializer < Panko::Serializer

data/benchmarks/bm_serializer_resolver.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+require_relative "./benchmarking_support"
+require_relative "./app"
+
+class NotSerializer
+end
+
+class RealSerializer < Panko::Serializer
+end
+
+Benchmark.run("CantFindConst") do
+  Panko::SerializerResolver.resolve("cant_find_const")
+end
+
+Benchmark.run("NotSerializer") do
+  Panko::SerializerResolver.resolve("not")
+end
+
+Benchmark.run("RealSerializer") do
+  Panko::SerializerResolver.resolve("real")
+end

data/docs/README.md

@@ -0,0 +1,11 @@
+* [Panko](../README.md)
+* [Getting Stated](getting-started.md)
+* Reference
+  * [Attributes](attributes.md)
+  * [Associations](associations.md)
+  * [Response bag](response-bag.md)
+* [Performance](performance.md)
+* [Design Choices](design-choices.md)
+
+
+

data/docs/associations.md

@@ -0,0 +1,76 @@
+# Associations
+
+A serializer can define it's own associations - both `has_many` and `has_one` to serializer under the context of the object.
+
+For example:
+
+```ruby
+class PostSerializer < Panko::Serailizer
+  attributes :title, :body
+
+  has_one :author, serializer: AuthorSerializer
+  has_many :comments, each_serializer: CommentSerializer
+end
+```
+
+### Inference
+
+Panko can find the type of the serializer by looking at the realtionship name, so instead specifying
+the serializer at the above example, we can -
+
+```ruby
+class PostSerializer < Panko::Serailizer
+  attributes :title, :body
+
+  has_one :author
+  has_many :comments
+end
+```
+
+The logic of inferencing is -
+- Take the name of the relationship (for example - `:author` / `:comments`) singularize and camelize it
+- Look for const defined with the name aboe and "Serializer" suffix (by using `Object.const_get`)
+
+> If Panko can't find the serializer it will throw an error on startup time, for example: `Can't find serializer for PostSerializer.author has_one relationship`
+
+## Nested Filters
+
+As talked before, Panko allows you to filter the attributes of a serializer.
+But Panko let you take that step further, and filters the attributes of you associations so you can re-use your serializers in your application.
+
+For example, let's say one portion of the application needs to serializer list of posts and serializer their - `title`, `body`, author's id and comments id.
+
+We can declare tailored serializer for this, or we can re-use the above defined serializer - `PostSerializer` and use nested filters.
+
+```ruby
+posts = Post.all
+
+Panko::ArraySerializer.new(posts, only: {
+  instance: [:title, :body, :author, :comments],
+  author: [:id],
+  comments: [:id],
+})
+```
+
+Let's disect `only` option we passed -
+* `instance` - list of attributes (and associations) we want to serializer for current instance of the serializer, in this case - `PostSerializer`.
+* `author`, `comments` - here we specify the list of attributes we want to serialize for each association.
+
+It's important to note that Nested Filters, are recursive, in other words, we can filter the association's associations.
+
+For example, `CommentSerializer` have has_one association `Author`, and for each `comments.author` we only it's name.
+
+```ruby
+posts = Post.all
+
+Panko::ArraySerializer.new(posts, only: {
+  instance: [:title, :body, :author, :comments],
+  author: [:id],
+  comments: {
+    instance: [:id, :author],
+    author: [:name]
+  }
+})
+```
+
+As you see now in `comments` the `instance` have differenet meaning, the `CommentSerializer`.

data/docs/attributes.md

@@ -0,0 +1,104 @@
+# 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.
+
+
+```ruby
+class UserSerializer < Panko::Serializer
+ attributes :full_name
+ 
+ def full_name
+  "#{object.first_name} #{object.last_name}"
+ end
+end
+```
+
+## Field Attributes
+
+Using field attributes you can control which columns of the given ActiveRecord object you want to serialize.
+
+Instead of relying ActiveRecord to do it's type casting, Panko does on it's own for performance reasons (read more in [Design Choices](design-choices.md#type-casting)).
+
+
+## Method Attributes
+
+Method attributes are used when your serialized values can be derived from the object you are serializing.
+
+The serializer's attribute methods can access the object being serialized as `object` -
+
+```ruby
+class PostSerializer < Panko::Serializer
+ def author_name
+  "#{object.author.first_name} #{object.author.last_name}"
+ end
+end
+```
+
+Another useful, thing you can pass your serializer is `context`, a `context` is a bag of data whom your serializer may need.
+
+For example, here we will pass the current user:
+```ruby
+class UserSerializer < Panko::Serializer
+  attributes :id, :email
+
+  def feature_flags
+    context[:feature_flags]
+  end
+end
+
+serializer = UserSerializer.new(context: {
+  feature_flags: FeatureFlags.all
+})
+
+serializer.serialize(User.first)
+```
+
+## Filters
+
+Filters allows us to reduce the amount of attributes we can serialize, therefore reduce the data usage & performance of serializing.
+
+There are two types of filters:
+  * only - use those attributes **only** and nothing else
+  * except - all attributes **except** those attributes
+
+Usage example:
+```ruby
+class UserSerializer < Panko::Serializer
+  attributes :id, :name, :email
+end
+
+# this line will return { 'name': '..' }
+UserSerializer.new(only: [:name]).serialize(User.first)
+
+# this line will return { 'id': '..', 'email': ... }
+UserSerializer.new(except: [:name]).serialize(User.first)
+```
+
+## Aliases
+
+Let's say we have attribute name that we want to expose to client as different name, the current way of doing so is using method attribute, for example:
+
+```ruby
+class PostSerializer < Panko::Serializer
+  attributes :published_at
+
+  def published_at
+    object.created_at
+  end
+end
+```
+
+The downside of this approach is that `created_at` skips Panko's type casting, therefore we get direct hit on performance.
+
+To fix this, we can use aliases -
+
+```ruby
+class PostSerializer < Panko::Serializer
+  aliases created_at: :published_at
+end
+```
+

data/docs/design-choices.md

@@ -0,0 +1,122 @@
+# Design Choices
+
+In short, Panko, is a serializer for ActiveRecord objects (it can't serialize any other object), which strives for high performance & simple API (which is inspired by ActiveModelSerializers).
+
+Its performance is achieved by:
+
+* `Oj::StringWriter` - I will elaborate later.
+* Type casting — instead of relying on ActiveRecord to do its type cast, Panko is doing it by itself.
+* Figuring out the metadata, ahead of time — therefore, we ask less questions during the `serialization loop`.
+
+
+## Serialization overview
+
+First, let's start with overview. Let's say we want to serialize `User` object, which has
+`first_name`, `last_name`, `age`, and `email` properties.
+
+The serializer definition will be something like this:
+
+```ruby
+class UserSerializer < Panko::Serializer
+  attributes :name, :age, :email
+  
+  def name
+    "#{object.first_name} #{object.last_name}"
+  end
+end
+```
+
+And the usage of this serializer will be:
+
+```ruby
+# fetch user from database
+user = User.first
+
+# create serializer, with empty options
+serializer = UserSerilizer.new
+
+# serialize to JSON
+serializer.serialize_to_json(user)
+```
+
+Let's go over the steps that Panko will execute behind the scenes for this flow.
+_I will skip the serializer definition part, because it's fairly simple and straightforward (see `lib/panko/serializer.rb`)_
+
+First step, while initializing the UserSerializer, we will create a **Serialization Descriptor** for this class.
+Serialization Descriptor's goal is to answer those questions:
+
+* Which fields do we have? In our case, `:age`, `:email`
+* Which method fields do we have? In our case `:name`
+* Which associations do we have (and their serialization descriptors)
+
+The serialization description is also responsible for filtering the attributes (`only` \ `except`).
+
+Now, that we have the serialization descriptor, we are finished with the Ruby part of Panko, and all we did here is done in *initialization time* and now we move to C code.
+
+In C land, we take the `user` object and the serialization descriptor, and start the serialization process which is separated to 4 parts:
+
+* Serializing Fields - looping through serialization descriptor's `fields` and read them from the ActiveRecord object (see `Type Casting`) and write them to the writer.
+* Serializing Method Fields - creating (a cached) serializer instance, setting its `@object` and `@context`, calling all the method fields and writing them to the writer.
+* Serializing associations — this is simple, once we have fields + method fields, we just repeat the process.
+
+Once this is finished, we have nice JSON string.
+Now let's dig deeper.
+
+## Interesting parts
+
+### Oj::StringWriter
+
+If you read the code of ActiveRecord serialization code in Ruby, you will observe this flow:
+
+1. Get an array of ActiveRecord objects (`User.all` for example)
+2. Build new array of hashes where each hash is `User` with the attributes we selected
+3. The JSON serializer, takes this array of hashes and loop them, and converts it to JSON string
+
+This entire process is expensive in terms of Memory & CPU, and this where the combination of Panko and Oj::StringWriter really shines. 
+
+In Panko, the serialization process of the above is:
+
+1. Get an array of ActiveRecord objects (`User.all` for example)
+2. Create `Oj::StringWriter` and feed the values to it, via `push_value` / `push_object` / `push_object` and behind the scene, `Oj::StringWriter` will serialize the objects incrementally into a string.
+3. Get from `Oj::StringWriter` the completed JSON string — which is a no-op, since `Oj::StringWriter` already built the string.
+
+### Figuring out the metadata, ahead of time.
+
+Another observation I noticed in the ruby serializers is that they ask and do a lot in a serialization loop: 
+
+* Is this field a method? is it a property?
+* Which fields and associations do I need for the serializer to consider the `only` and `except` options
+* What is the serializer of this has_one association?
+
+Panko tries to ask the bare minimum in serialization by building `Serialization Descriptor` for each serialization and caching it.
+
+The Serialization Descriptor will do the filtering of `only` and `except` and will check if a field is a method or not (therefore Panko doesn't have list of `attributes`)
+
+
+### Type Casting
+
+This is the final part, which helped yield most of the performance improvements.
+In ActiveRecord, when we read a value of attribute, it does type casting of the DB value to its real ruby type.
+
+For example, time strings are converted to Time objects, Strings are duplicated, and Integers are converts from their values to Number.
+
+This type casting is really expensive, as it's responsible for most of the allocations in the serialization flow and most of them can be "relaxed".
+
+If we think about it, we don't need to duplicate strings or convert time strings to time objects or even parse JSON strings for the JSON serialization process.
+
+What Panko does is that if we have ActiveRecord type string, we won't duplicate it.
+If we have an integer string value, we will convert it to an integer, and the same goes for other types.
+
+All of these conversions are done in C, which of course yields a big performance improvement.
+
+#### Time type casting
+While you read Panko source code, you will encounter the time type casting and immediately you will have a "WTF?" moment.
+
+The idea behind the time type casting code relies on the end result of JSON type casting — what we need in order to serialize Time to JSON? UTC ISO8601 time format representation.
+
+The time type casting works as follows:
+
+* If it's a string that ends with `Z`, and the strings matches the UTC ISO8601 regex, then we just return the string.
+* If it's a string and it doesn't follow the rules above, we check if it's a timestamp in database format and convert it via regex + string concat to UTC ISO8601 - Yes, there is huge assumption here, that the database returns UTC timestamps — this will be configureable (before Panko official release).
+* If it's none of the above, I will let ActiveRecord type casting do it's magic.
+

data/docs/docpress.json

@@ -0,0 +1,4 @@
+{
+  "docs": "docs",
+  "github": "yosiat/panko_serializer"
+}

data/docs/getting-started.md

@@ -0,0 +1,47 @@
+# Getting Started
+
+## 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
+```
+
+
+## Creating your first serializer
+
+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.new(users, each_serializer: UserSerializer).to_json
+ end
+end
+```
+
+And voila, we have endpoint which serialize users using Panko!
+

data/docs/performance.md

@@ -0,0 +1,35 @@
+# Performance
+
+The performance of Panko is measured using microbenchmarks and load testing.
+
+## Microbenchmarks
+
+The following microbenchmarks are run on MacBook Pro (Retina, 15-inch, Mid 2015), Ruby 2.4 with Rails 4.2
+demonstrating the performance of ActiveModelSerializers 0.9 and Panko 0.3.3
+
+
+ Benchmark                             | AMS ip/s     | Panko ip/s
+---------------------------------------|----------|-----------------
+| Simple_Posts_2300               | 25.81   | 135.29         |
+| Simple_Posts_50                 | 1,248.39 | 6,518.68          |
+| HasOne_Posts_2300               | 11.33     | 73.42         |
+| HasOne_Posts_50                 | 523.14  | 4,985.41           |
+
+> The corresponding benchmarks are `benchmarks/bm_active_model_serializers.rb` and `benchmarks/bm_panko_json.rb`
+
+
+## Real-world benchmark
+
+The real-world benchmark here is endpoint which serializes 7,884 entries with 48 attributes and no associations.
+The benchmark took place in environment that simulates production environment and run using `wrk` from machine on the same cluster.
+
+
+Metric | AMS | Panko
+------------ |------------ | -------------
+Avg Response Time| 4.89s| 1.48s|
+Max Response Time| 5.42s| 1.83s|
+99th Response Time| 5.42s| 1.74s|
+Total Requests| 61| 202|
+
+
+*Thanks to [Bringg](https://www.bringg.com) for providing the infrastructrue for the benchmarks*

data/docs/response-bag.md

@@ -0,0 +1,53 @@
+# Response
+
+Let's say you have some JSON payload which can is constructed using Panko serialization result,
+like this:
+
+```ruby
+class PostsController < ApplicationController
+  def index
+   posts = Post.all
+   render json: {
+     success: true,
+     total_count: posts.count,
+     posts: Panko::ArraySerializer.new(posts, each_serializer: PostSerializer).to_json
+   }
+  end
+end
+```
+
+The output of the above will be json string (for `posts`) inside json string and this were `Panko::Response` shines.
+
+```ruby
+class PostsController < ApplicationController
+  def index
+   posts = Post.all
+   render json: Panko::Response.new(
+     success: true,
+     total_count: posts.count,
+     posts: Panko::ArraySerializer.new(posts, each_serializer: PostSerializer)
+   )
+  end
+end
+```
+
+And everything will work as expected!
+
+## JsonValue
+
+Let's take the above example further, we serialized the posts and cached it as JSON string in our Cache.
+Now, you can wrap the cached value with `Panko::JsonValue`, like here -
+
+```ruby
+class PostsController < ApplicationController
+  def index
+   posts = Cache.get("/posts")
+
+   render json: Panko::Response.new(
+     success: true,
+     total_count: posts.count,
+     posts: Panko::JsonValue.from(posts)
+   )
+  end
+end
+```

data/ext/panko_serializer/association.c

@@ -56,6 +56,11 @@ VALUE association_name_sym_ref(VALUE self) {
   return association->name_sym;
 }
 
+VALUE association_name_str_ref(VALUE self) {
+  Association association = (Association)DATA_PTR(self);
+  return association->name_str;
+}
+
 VALUE association_descriptor_ref(VALUE self) {
   Association association = (Association)DATA_PTR(self);
   return association->rb_descriptor;
@@ -76,6 +81,7 @@ void panko_init_association(VALUE mPanko) {
   rb_define_module_function(cAssociation, "new", association_new, -1);
 
   rb_define_method(cAssociation, "name_sym", association_name_sym_ref, 0);
+  rb_define_method(cAssociation, "name_str", association_name_str_ref, 0);
   rb_define_method(cAssociation, "descriptor", association_descriptor_ref, 0);
   rb_define_method(cAssociation, "descriptor=", association_decriptor_aset, 1);
 }

data/lib/panko/serialization_descriptor.rb

@@ -20,9 +20,7 @@ module Panko
 
       backend.type = descriptor.type
 
-      backend.attributes = descriptor.attributes.map do |attr|
-        Attribute.create(attr.name, alias_name: attr.alias_name)
-      end
+      backend.attributes = descriptor.attributes.dup
 
       backend.method_fields = descriptor.method_fields.dup
 
@@ -30,21 +28,8 @@ module Panko
         backend.serializer = descriptor.serializer.reset
       end
 
-      backend.has_many_associations = descriptor.has_many_associations.map do |assoc|
-        Panko::Association.new(
-          assoc.name_sym,
-          assoc.name_sym.to_s,
-          Panko::SerializationDescriptor.duplicate(assoc.descriptor)
-        )
-      end
-
-      backend.has_one_associations = descriptor.has_one_associations.map do |assoc|
-        Panko::Association.new(
-          assoc.name_sym,
-          assoc.name_sym.to_s,
-          Panko::SerializationDescriptor.duplicate(assoc.descriptor)
-        )
-      end
+      backend.has_many_associations = descriptor.has_many_associations.dup
+      backend.has_one_associations = descriptor.has_one_associations.dup
 
       backend
     end
@@ -58,7 +43,8 @@ module Panko
       attributes_only_filters, associations_only_filters = resolve_filters(options, :only)
       attributes_except_filters, associations_except_filters = resolve_filters(options, :except)
 
-      apply_attribute_filters!(
+      self.attributes = apply_attribute_filters(
+        self.attributes,
         attributes_only_filters,
         attributes_except_filters
       )
@@ -120,10 +106,17 @@ module Panko
         filters = {}
         filters[:only] = only_filter unless only_filter.nil?
         filters[:except] = except_filter unless except_filter.nil?
-        descriptor.apply_filters(filters) unless filters.empty?
+
+        unless filters.empty?
+          next Panko::Association.new(
+            name,
+            association.name_str,
+            Panko::SerializationDescriptor.build(descriptor.type, filters)
+          )
+        end
 
         association
-      end.compact
+      end
     end
 
     def resolve_filters(options, filter)
@@ -152,9 +145,9 @@ module Panko
       fields
     end
 
-    def apply_attribute_filters!(only, except)
+    def apply_attribute_filters(attributes, only, except)
       unless only.empty?
-        self.attributes.select! do |attribute|
+        attributes = attributes.select do |attribute|
           name_to_check = attribute.name
           name_to_check = attribute.alias_name unless attribute.alias_name.nil?
 
@@ -163,13 +156,15 @@ module Panko
       end
 
       unless except.empty?
-        self.attributes.reject! do |attribute|
+        attributes = attributes.reject do |attribute|
           name_to_check = attribute.name
           name_to_check = attribute.alias_name unless attribute.alias_name.nil?
 
           except.include?(name_to_check.to_sym)
         end
       end
+
+      attributes
     end
   end
 end

data/lib/panko/serializer.rb

@@ -36,8 +36,13 @@ module Panko
         @_descriptor.method_fields << method
       end
 
-      def has_one(name, options)
+      def has_one(name, options = {})
         serializer_const = options[:serializer]
+        serializer_const = Panko::SerializerResolver.resolve(name.to_s) if serializer_const.nil?
+
+        if serializer_const.nil?
+          raise "Can't find serializer for #{self.name}.#{name} has_one relationship."
+        end
 
         @_descriptor.has_one_associations << Panko::Association.new(
           name,
@@ -46,8 +51,13 @@ module Panko
         )
       end
 
-      def has_many(name, options)
+      def has_many(name, options = {})
         serializer_const = options[:serializer] || options[:each_serializer]
+        serializer_const = Panko::SerializerResolver.resolve(name.to_s) if serializer_const.nil?
+
+        if serializer_const.nil?
+          raise "Can't find serializer for #{self.name}.#{name} has_many relationship."
+        end
 
         @_descriptor.has_many_associations << Panko::Association.new(
           name,

data/lib/panko/serializer_resolver.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+require "byebug"
+
+class Panko::SerializerResolver
+
+  def self.resolve(name)
+    serializer_name = "#{name.singularize.camelize}Serializer"
+    serializer_const = self.safe_const_get(serializer_name)
+
+    return nil if serializer_const.nil?
+    return nil unless self.is_serializer(serializer_const)
+
+    serializer_const
+  end
+
+
+  private
+
+  def self.is_serializer(const)
+    const < Panko::Serializer
+  end
+
+  def self.safe_const_get(name)
+    Object.const_get(name)
+  rescue NameError
+    nil
+  end
+
+end

data/lib/panko/version.rb

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

data/lib/panko_serializer.rb

@@ -4,6 +4,7 @@ require "panko/attribute"
 require "panko/serializer"
 require "panko/array_serializer"
 require "panko/response"
+require "panko/serializer_resolver"
 
 
 # C Extension

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: panko_serializer
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Yosi Attias
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-04 00:00:00.000000000 Z
+date: 2017-12-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -97,7 +97,6 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
-- _config.yml
 - benchmarks/BENCHMARKS.md
 - benchmarks/allocs.rb
 - benchmarks/app.rb
@@ -107,12 +106,21 @@ files:
 - benchmarks/bm_panko_json.rb
 - benchmarks/bm_panko_object.rb
 - benchmarks/bm_serialization_descriptor.rb
+- benchmarks/bm_serializer_resolver.rb
 - benchmarks/profile.rb
 - benchmarks/sanity.rb
 - benchmarks/setup.rb
 - benchmarks/type_casts/bm_active_record.rb
 - benchmarks/type_casts/bm_panko.rb
 - benchmarks/type_casts/support.rb
+- docs/README.md
+- docs/associations.md
+- docs/attributes.md
+- docs/design-choices.md
+- docs/docpress.json
+- docs/getting-started.md
+- docs/performance.md
+- docs/response-bag.md
 - ext/panko_serializer/association.c
 - ext/panko_serializer/association.h
 - ext/panko_serializer/attribute.c
@@ -133,6 +141,7 @@ files:
 - lib/panko/response.rb
 - lib/panko/serialization_descriptor.rb
 - lib/panko/serializer.rb
+- lib/panko/serializer_resolver.rb
 - lib/panko/version.rb
 - lib/panko_serializer.rb
 - panko_serializer.gemspec
@@ -156,7 +165,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.3
 signing_key: 
 specification_version: 4
 summary: Fast serialization for ActiveModel

data/_config.yml

@@ -1 +0,0 @@
-theme: jekyll-theme-cayman