jsonapi_serializer 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 21d607d922e598bf9866f8b829def185ff0f1f72
-  data.tar.gz: 5a80e053e723f7180018d582d2871426f713723f
+SHA256:
+  metadata.gz: 54a1f6c12504a34ad1658cc5324b324d374e510018db28b152bf9f043d26fc3e
+  data.tar.gz: 201ed0fc8df08e5c4abc74fcd18493f9e5711d0612f397c9d369b11b8fd08c58
 SHA512:
-  metadata.gz: 1c727a0615f60c522a665e6725e91b8a5770d8c959cf60f4ebb176da8db2d5322e2bb8faeb6eb239e106e3a9d71a4b7bcfcae2f4163b5c72c7274dab0cdd0820
-  data.tar.gz: 88855eeaf4da64bd790379072c66881512ca675c5d0137600314200df71795ce94cbb58072a83363407557ce533ab416964ceea647855ef3207e89813c66b805
+  metadata.gz: fd85b7ace1691b5916781df14b6074d77502b3eb8b387b86875f4bdf587d39e3ccd3eba6d9ce0d218489e5f0f94d7ff8911beada569cf4f5dbd15a99fe3e668c
+  data.tar.gz: fdc211f59a28ded7c07cbf56109673047285e09a3650d62d66f09fed509e8a3b996e944f47f6278bd67db67d99db0fbe59bb6d1a8a6c5e672bb434ae31f9b663

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+### 0.1.1
+
+- Support for lambda as a source of relationships (`from` parameter)
+- Instance level attributes for fields and includes are removed in favor of initialization-time variables distribution (No public API changed)
+- Fixed bug when `key_transform` didn't have an effect on serialized attributes and relationships.
+
+### 0.1.0
+
+Initial release

data/README.md

@@ -82,8 +82,8 @@ JsonapiSerializer.set_type_namespace_separator :ignore
 
 # The default option is "_"
 # Bear in mind that only " " (space), "_" and "-" or any combination of these
-# are allowed as per json-api spec and attempt to set anything else
-# will cause an error.   
+# are allowed as per json-api spec, but in practice you can use other symbols if you
+# make sure to escape them while using in urls.
 ```
 
 ### Attributes configuration
@@ -118,13 +118,17 @@ In this example, serializer will access `record.name` and `record.year` to fill
 
 ### Relationships configuration
 
-In order to define relationships, you can use `belongs_to` and `has_many` DSL methods. They accept options `serializer` and `from`. By default, serializer will try to guess relationship serializer by the name of relation. In case of `:director` relation, it would try to use `DirectorSerializer` and crash since it's not defined. Use `serializer` parameter to set serializer explicitly. Option `from` is used to point at the attribute of the model that actually returns the relation object(s) if it's different.
+In order to define relationships, you can use `belongs_to` and `has_many` DSL methods. They accept options `serializer` and `from`. By default, serializer will try to guess relationship serializer by the name of relation. In case of `:director` relation, it would try to use `DirectorSerializer` and crash since it's not defined. Use `serializer` parameter to set serializer explicitly. Option `from` is used to point at the attribute of the model that actually returns the relation object(s) if it's different. You can also supply lambda, if the relation is accessible in some non-trivial way.
 
 ```ruby
 class MovieSerializer
   include JsonapiSerializer::Base
   belongs_to :director, serializer: PersonSerializer
   has_many :actors, from: :cast
+
+  # or if you want to introduce some logic in building relationships
+  has_many :male_actors, from: lambda { |movie| movie.cast.where(sex: "m") }
+  has_many :female_actors, from: lambda { |movie| movie.cast.where(sex: "f") }
 end
 ```
 
@@ -137,7 +141,7 @@ From the perspective of serializer, there is no distinction between `belongs_to`
 
 There are two kinds of polymorphism that `jsonapi_serializer` supports. First is polymorphic model (STI models in ActiveRecord), where most attributes are shared, but children have different types. Ultimately it is still one kind of entity: think of `Vehicle` base class inherited by `Car`, `Truck` and `Motorcycle`. Second kind is polymorphic relationship, where one relationship can contain entirely different models. Let's say you have `Post` and `Product`, and both can have comments, hence from the perspective of individual comment it belongs to `Commentable`. Even though `Post` and `Model` can share some attributes, their serializers will be used mostly along from comments.
 
-These types of serializers share most of the implementation implemented similarly, they share most of the logic and both need a `resolver`, which is implicitly defined as a lambda, that applies `JsonapiSerializer.type_transform` to the record class name.
+These types of serializers share most of the implementation and both rely on `resolver`, which is implicitly defined as a lambda, that applies `JsonapiSerializer.type_transform` to the record class name.
 
 #### Polymorphic Models
 
@@ -209,6 +213,8 @@ Once serializers are defined, you can instantiate them with several options. Cur
 
 `fields` must be a hash, where keys represent record types and values are list of attributes and relationships of the corresponding type that will be present in serialized object. If some type is missing, that means all attributes and relationships defined in serializer will be serialized. In case of `polymorphic` serializer, you can supply shared fields under polymorphic type. **_There is a caveat, though: if you define a fieldset for a parent polymorphic class and omit fieldsets for subclasses it will be considered that you did not want any of attributes and relationships defined in subclass to be serialized._** It works the same fashion for polymorphic relationships, so if you want only `title` from `Post` and `name` from `Product`, you can supply `{commentable: ["title", "name"]}` as a `fields` parameter for `CommentableSerializer`.
 
+`fields` must have attributes as seen by API consumer. For example, if you have `key_transform` set to `:camelize`, then fields will be expected as `{"movie" => ["movieTitle", "releaseYear"]}`, you can use symbols or strings, they will be normallized on serializer instantiation.
+
 `include` defines an arbitrary depth tree of included relationships in a similar way as ActiveRecord's `includes`. Bear in mind that `fields` has precedence, which means that if some relationship is missing in fields, it will not be included either.  
 
 ```ruby
@@ -236,23 +242,42 @@ serializer.serialazable_hash(movies, meta: meta)
 serializer.serialized_json(movies, meta: meta)
 ```
 
+### Utils
+
+`JsonapiSerializer` provides some convenience methods for converting `fields` and `include` from query parameters into the form accepted by the serializer.
+
+#### Fields converter
+
+```ruby
+JsonapiSerializer.convert_fields({"articles" => "title,body", "people" => "name"})
+# {articles: [:title, :body], people: [:name]}
+```
+
+#### Include converter
+
+```ruby
+JsonapiSerializer.convert_include("author,comments.author,comments.theme")
+# {author: {}, comments: {author: {}, theme: {}}}
+end
+```
+
 ## Performance
 
 By running `bin/benchmark` you can launch performance test locally, however numbers are fluctuating widely. The example output is as follows:
 
 ### Base case
 
-|       Adapters       |  10 hash/json (ms)   |  100 hash/json (ms)  | 1000 hash/json (ms)  | 10000 hash/json (ms) |
-| -------------------- |:--------------------:|:--------------------:|:--------------------:|:--------------------:|
-|    JsonapiSerializerTest    |     0.36 / 1.17      |     1.55 / 1.98      |    13.74 / 20.18     |   156.31 / 208.86    |
-|   FastJsonapiTest    |     0.16 / 0.19      |     1.14 / 1.75      |    11.86 / 18.13     |   124.13 / 176.97    |
+|         Adapters         |    10 hash/json (ms)     |    100 hash/json (ms)    |   1000 hash/json (ms)    |   10000 hash/json (ms)   |
+| ------------------------ |:------------------------:|:------------------------:|:------------------------:|:------------------------:|
+|  JsonapiSerializerTest   |       0.39 / 1.17        |       1.32 / 1.75        |      11.26 / 16.55       |     118.13 / 179.28      |
+|     FastJsonapiTest      |       0.16 / 0.19        |       1.12 / 1.60        |      10.71 / 16.02       |     104.76 / 160.39      |
 
 ### With includes
 
-|       Adapters       |  10 hash/json (ms)   |  100 hash/json (ms)  | 1000 hash/json (ms)  | 10000 hash/json (ms) |
-| -------------------- |:--------------------:|:--------------------:|:--------------------:|:--------------------:|
-|    JsonapiSerializerTest    |     0.51 / 0.46      |     2.05 / 2.50      |    15.28 / 21.59     |   159.89 / 214.49    |
-|   FastJsonapiTest    |     0.26 / 0.25      |     2.01 / 2.47      |    15.54 / 20.11     |   154.82 / 211.48    |
+|         Adapters         |    10 hash/json (ms)     |    100 hash/json (ms)    |   1000 hash/json (ms)    |   10000 hash/json (ms)   |
+| ------------------------ |:------------------------:|:------------------------:|:------------------------:|:------------------------:|
+|  JsonapiSerializerTest   |       0.48 / 0.44        |       1.72 / 2.47        |      13.04 / 17.71       |     125.47 / 179.12      |
+|     FastJsonapiTest      |       0.27 / 0.26        |       1.84 / 2.11        |      13.64 / 17.85       |     141.91 / 222.25      |
 
 Performance tests do not include any advanced features, such as fieldsets, nested includes or polymorphic serializers, and were mostly intended to make sure that adding these features did not make serializer slower (or at least significantly slower), but there are models prepared to extend these tests. PRs are welcome.
 

data/bin/benchmark

@@ -2,16 +2,21 @@
 
 require "bundler/setup"
 require "jsonapi_serializer"
+require "ruby-prof"
 require "./perf/runner"
 require "./perf/jsonapi_serializer_test"
 require "./perf/fast_jsonapi_test"
 GC.disable
+# RubyProf.measure_mode = RubyProf::WALL_TIME
 
 runner = Runner.new(10_000)
 runner.set_modules(JsonapiSerializerTest, FastJsonapiTest)
 runner.set_tests(:base, :with_included)
 runner.set_takes(10, 100, 1000, 10_000)
-runner.run
+
+# result = RubyProf.profile do
+  runner.run
+# end
 
 print "\n"
 print "### Base case\n"
@@ -21,3 +26,6 @@ print "\n"
 print "### With includes\n"
 print "\n"
 runner.print_table(:with_included)
+
+# printer = RubyProf::GraphPrinter.new(result)
+# printer.print(STDOUT, {})

data/jsonapi_serializer.gemspec

@@ -26,5 +26,6 @@ Gem::Specification.new do |spec|
   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 "ruby-prof"
   spec.add_development_dependency "fast_jsonapi", "~> 1.0"
 end

data/lib/jsonapi_serializer/base.rb

@@ -15,12 +15,15 @@ module JsonapiSerializer::Base
     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
+      fields = normalize_fields(opts.fetch(:fields, {}))
+      if opts[:poly_fields].present?
+        fields[@type] = fields.fetch(@type, []) + opts[:poly_fields]
+      end
+
+      includes = normalize_includes(opts.fetch(:include, {}))
+
+      prepare_attributes(fields)
+      prepare_relationships(fields, includes)
     end
   end
 
@@ -35,19 +38,15 @@ module JsonapiSerializer::Base
   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)
+    @relationships.each_with_object({}) do |(key, from, serializer, included), hash|
+      if relation = from.call(record)
+        if relation.respond_to?(:map)
+          relation_ids = relation.map do |item|
+            process_relation(item, serializer, context, included)
           end
+          hash[key] = {data: relation_ids}
         else
-          id = serializer.id_hash(rel)
-          hash[key] = {data: id}
-          add_included(serializer, rel, id, context) if @includes.has_key?(key)
+          hash[key] = {data: process_relation(relation, serializer, context, included)}
         end
       else
         hash[key] = {data: nil}
@@ -66,34 +65,37 @@ module JsonapiSerializer::Base
   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]]
+  def prepare_attributes(all_fields)
+    @attributes = []
+    fields = all_fields[@type]
+    self.class.meta_attributes.each do |attribute, getter|
+      key = JsonapiSerializer.key_transform(attribute)
+      if fields.nil? || fields.include?(key)
+        @attributes << [key, getter]
+      end
     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]
+  def prepare_relationships(all_fields, includes)
+    @relationships = []
+    relations = all_fields[@type]
+    self.class.meta_relationships.each do |relation, cfg|
+      key = JsonapiSerializer.key_transform(relation)
+      if relations.nil? || relations.include?(key)
+        included = includes.has_key?(relation)
+        serializer = cfg[:serializer].to_s.constantize.new(
+          fields: all_fields,
+          include: includes.fetch(relation, {}),
+          id_only: !included
+        )
+        @relationships << [relation, cfg[:from], serializer, included]
+      end
     end
   end
 
-  def add_included(serializer, item, id, context)
-    if (context[:tracker][id[:type]] ||= Set.new).add?(id[:id]).present?
+  def process_relation(item, serializer, context, included)
+    id = serializer.id_hash(item)
+    if included && (context[:tracker][id[:type]] ||= Set.new).add?(id[:id]).present?
       attributes = serializer.attributes_hash(item)
       relationships = serializer.relationships_hash(item, context)
       inc = id.clone
@@ -101,5 +103,6 @@ module JsonapiSerializer::Base
       inc[:relationships] = relationships if relationships.present?
       context[:included] << inc
     end
+    id
   end
 end

data/lib/jsonapi_serializer/dsl/common.rb

@@ -11,6 +11,9 @@ module JsonapiSerializer::DSL
       @meta_relationships = {}
 
       class << self
+        alias_method :has_many, :relationship
+        alias_method :belongs_to, :relationship
+
         attr_reader :meta_type, :meta_id, :meta_attributes, :meta_relationships
       end
     end
@@ -35,7 +38,7 @@ module JsonapiSerializer::DSL
         attrs.each do |attr|
           case attr
           when Symbol, String
-            @meta_attributes[attr.to_sym] = lambda { |obj| obj.public_send(attr.to_sym) }
+            @meta_attributes[attr.to_sym] = lambda { |obj| obj.public_send(attr) }
           when Hash
             attr.each do |key, val|
               @meta_attributes[key] = lambda { |obj| obj.public_send(val) }
@@ -45,32 +48,21 @@ module JsonapiSerializer::DSL
       end
 
       def attribute(attr, &block)
-        @meta_attributes[attr.to_sym] = block
+        @meta_attributes[attr.to_sym] = block_given? ? block : lambda { |obj| obj.public_send(attr) }
       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 relationship(name, opts = {})
+        @meta_relationships[name.to_sym] = {}.tap do |relationship|
+          from = opts.fetch(:from, name)
+          relationship[:from] = from.respond_to?(:call) ? from : lambda { |r| r.public_send(from) }
 
-      def belongs_to(name, opts = {})
-        @meta_relationships[name] = {
-          type: :belongs_to,
-          from: opts.fetch(:from, name),
-          serializer: opts[:serializer] || guess_serializer(name.to_s)
-        }
+          serializer = opts[:serializer]
+          relationship[:serializer] = serializer ? serializer.to_s : "#{name.to_s.singularize.classify}Serializer"
+        end
       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
+        raise "You attempted to inherit from #{self.name}, if you want to create Polymorphic serializer, include JsonapiSerializer::Polymorphic"
       end
     end
   end

data/lib/jsonapi_serializer/dsl/polymorphic.rb

@@ -25,7 +25,7 @@ module JsonapiSerializer::DSL
       end
 
       def polymorphic_for(*serializers)
-        @meta_poly += serializers
+        @meta_poly += serializers.map(&:to_s)
       end
 
       def inherited(subclass)
@@ -37,7 +37,7 @@ module JsonapiSerializer::DSL
           @meta_id = parent.meta_id
           @meta_inherited = true
         end
-        @meta_poly << subclass
+        @meta_poly << subclass.to_s
       end
     end
   end

data/lib/jsonapi_serializer/polymorphic.rb

@@ -15,14 +15,10 @@ module JsonapiSerializer::Polymorphic
   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)
+          serializer = poly_class.constantize.new(opts.merge poly_fields: poly_fields)
           hash[serializer.type] = serializer
         end
       else
@@ -57,6 +53,10 @@ module JsonapiSerializer::Polymorphic
 
   private
   def serializer_for(record)
-    @poly[self.class.meta_resolver.call(record)] || (raise "Could not resolve serializer for #{record} associated with #{self.class.name}")
+    if serializer = @poly[self.class.meta_resolver.call(record)]
+      serializer
+    else
+     raise "Could not resolve serializer for #{record} associated with #{self.class.name}"
+    end
   end
 end

data/lib/jsonapi_serializer/utils.rb

@@ -22,6 +22,12 @@ module JsonapiSerializer::Utils
     end
   end
 
+  def normalize_fields(fields)
+    fields.each_with_object({}) do |(type, attributes), hash|
+      hash[type.to_sym] = [*attributes].map(&:to_sym)
+    end
+  end
+
   def apply_splat(item, &block)
     if item.is_a? Array
       item.map { |i| block.call(i) }

data/lib/jsonapi_serializer/version.rb

@@ -1,3 +1,3 @@
 module JsonapiSerializer
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/perf/models.rb

@@ -1,7 +1,7 @@
 require 'ffaker'
 
 class Book
-  attr_accessor :id, :name, :isbn, :year, :author, :author_id, :characters, :character_ids, :librarians, :librarian_ids
+  attr_accessor :id, :name, :isbn, :year, :author, :author_id, :characters, :character_ids
 
   @characters = []
   @character_ids = []

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jsonapi_serializer
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Ivan Yurov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-02-22 00:00:00.000000000 Z
+date: 2018-02-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -108,6 +108,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 2.8.1
+- !ruby/object:Gem::Dependency
+  name: ruby-prof
+  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'
 - !ruby/object:Gem::Dependency
   name: fast_jsonapi
   requirement: !ruby/object:Gem::Requirement
@@ -132,6 +146,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".travis.yml"
+- CHANGELOG.md
 - CODE_OF_CONDUCT.md
 - Gemfile
 - LICENSE.txt
@@ -174,7 +189,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Alternative JSONApi serializer