fast_serializer_ruby 0.6.0 → 0.6.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 443a464f8f7d09a40c3457933896eaa35a27c841db28a259dd6fd95edbf2ddd1
-  data.tar.gz: 1ab61528123941c2d6905795ca0c9f5bc95dab2982635300344b0eabdd3d62d6
+  metadata.gz: 4adafc96834175b06d1d49a72269b461f0d72419286a03e3c6422d145e027672
+  data.tar.gz: 5422eeac009a270dffbc56a7234b74da8c6a38eb56fbca9a66121f96ee129e3c
 SHA512:
-  metadata.gz: cbe8efbf120d930648abb69eca0b541ffe73181a2f63b1f0e0b4132506fb699e7a3b7007cf1f5c2e97415ef3936539222c282d7ea8766214b4a69e5c73b5d4b9
-  data.tar.gz: 8f66f7174aa206a31c1b7885c2e1f2deae54fe882870db55017bef74363cae428bc8e14d20fcd925cca9cedb8041ef10349672a21feaf279a97577e4932d9cdb
+  metadata.gz: b6571bed32c87ef3dacb6ad00a6d0054aa547f8afe4f196b1a9186d6d6eedc649aaa81c8f22a72114e74547a9ec8d61a9df0229415ff92370a58c06e3ad3c91b
+  data.tar.gz: 0567dc3d3513358831e4571833daeb941ebc94660d945240038669e3f2c20deedb99d16337055336b88afe1110b6061800b994ab7fe8f6a40ef54cfd1bfa6c06

data/.gitignore

@@ -13,3 +13,5 @@
 .rspec_status
 .rspec
 .history
+/.vscode
+.rubocop.yml

data/Gemfile

@@ -6,8 +6,8 @@ git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
 
 gemspec
 
-group :development do
-  gem 'pry-byebug', '~> 3.7.0'
+group :development, :test do
+  gem 'rake'
   gem 'pry'
 end
 
@@ -15,6 +15,7 @@ group :test do
   gem 'active_model_serializers', '~> 0.10.0'
   gem 'factory_bot'
   gem 'faker'
+  gem 'activesupport', '< 6'
   gem 'allocation_stats'
   gem 'simplecov', '~> 0.17.1'
   gem 'benchmark-memory', '~> 0.1'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    fast_serializer_ruby (0.6.0)
+    fast_serializer_ruby (0.6.2)
 
 GEM
   remote: https://rubygems.org/
@@ -32,28 +32,29 @@ GEM
       minitest (~> 5.1)
       tzinfo (~> 1.1)
     allocation_stats (0.1.5)
-    benchmark-malloc (0.1.0)
+    benchmark-malloc (0.2.0)
     benchmark-memory (0.1.2)
       memory_profiler (~> 0.9)
-    benchmark-perf (0.5.0)
-    benchmark-trend (0.3.0)
+    benchmark-perf (0.6.0)
+    benchmark-trend (0.4.0)
     builder (3.2.4)
-    byebug (11.0.1)
     case_transform (0.2)
       activesupport
     coderay (1.1.2)
-    concurrent-ruby (1.1.5)
+    concurrent-ruby (1.1.6)
     crass (1.0.6)
     diff-lcs (1.3)
     docile (1.3.2)
     erubi (1.9.0)
     factory_bot (5.1.1)
       activesupport (>= 4.2.0)
-    faker (2.10.1)
+    faker (2.10.2)
       i18n (>= 1.6, < 2)
+    ffi (1.12.2-java)
     i18n (1.8.2)
       concurrent-ruby (~> 1.0)
     json (2.3.0)
+    json (2.3.0-java)
     jsonapi-renderer (0.2.2)
     loofah (2.4.0)
       crass (~> 1.0.2)
@@ -62,15 +63,17 @@ GEM
     method_source (0.9.2)
     mini_portile2 (2.4.0)
     minitest (5.14.0)
-    nokogiri (1.10.7)
+    nokogiri (1.10.9)
       mini_portile2 (~> 2.4.0)
+    nokogiri (1.10.9-java)
     pry (0.12.2)
       coderay (~> 1.1.0)
       method_source (~> 0.9.0)
-    pry-byebug (3.7.0)
-      byebug (~> 11.0)
-      pry (~> 0.10)
-    rack (2.1.2)
+    pry (0.12.2-java)
+      coderay (~> 1.1.0)
+      method_source (~> 0.9.0)
+      spoon (~> 0.0)
+    rack (2.2.2)
     rack-test (1.1.0)
       rack (>= 1.0, < 3)
     rails-dom-testing (2.0.3)
@@ -78,18 +81,19 @@ GEM
       nokogiri (>= 1.6)
     rails-html-sanitizer (1.3.0)
       loofah (~> 2.3)
+    rake (13.0.1)
     rspec (3.9.0)
       rspec-core (~> 3.9.0)
       rspec-expectations (~> 3.9.0)
       rspec-mocks (~> 3.9.0)
-    rspec-benchmark (0.5.1)
-      benchmark-malloc (~> 0.1.0)
-      benchmark-perf (~> 0.5.0)
-      benchmark-trend (~> 0.3.0)
-      rspec (>= 3.0.0, < 4.0.0)
+    rspec-benchmark (0.6.0)
+      benchmark-malloc (~> 0.2)
+      benchmark-perf (~> 0.6)
+      benchmark-trend (~> 0.4)
+      rspec (>= 3.0)
     rspec-core (3.9.1)
       rspec-support (~> 3.9.1)
-    rspec-expectations (3.9.0)
+    rspec-expectations (3.9.1)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.9.0)
     rspec-mocks (3.9.1)
@@ -101,22 +105,27 @@ GEM
       json (>= 1.8, < 3)
       simplecov-html (~> 0.10.0)
     simplecov-html (0.10.2)
+    spoon (0.0.6)
+      ffi
     thread_safe (0.3.6)
+    thread_safe (0.3.6-java)
     tzinfo (1.2.6)
       thread_safe (~> 0.1)
 
 PLATFORMS
+  java
   ruby
 
 DEPENDENCIES
   active_model_serializers (~> 0.10.0)
+  activesupport (< 6)
   allocation_stats
   benchmark-memory (~> 0.1)
   factory_bot
   faker
   fast_serializer_ruby!
   pry
-  pry-byebug (~> 3.7.0)
+  rake
   rspec (~> 3.0)
   rspec-benchmark
   simplecov (~> 0.17.1)

data/README.md

@@ -9,9 +9,9 @@
 This library intends to solve such a typical and on the other hand important problem as efficient ruby object to hash transformation.
 
 ## Performance 🚀
-- running on ruby 2.6 is **at least 5 times faster** than AMS (benchmarks was borrowed from fast_jsonapi repository)
-- running on ruby 2.6 it consumes **3 times less RAM**
-- running on jruby 9.2.7.0 **is at least 15 times faster** than AMS after warming up
+- running on ruby 2.7 is **at least 6 times faster** than AMS (benchmarks was borrowed from fast_jsonapi repository)
+- running on ruby 2.7 it consumes **6 times less RAM**
+- running on jruby 9.2.7.0 **is at least 4 times faster** than AMS after warming up
 
 ## Compatibility 👌
 I tried to keep the API as close as possible to active_model_serializer implementation because we all got used to it.

data/fast_serializer.gemspec

@@ -33,6 +33,7 @@ Gem::Specification.new do |spec|
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{(test|spec|features|git|rspec|travis)/}) }
   end
+
   spec.bindir        = 'bin'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']

data/lib/fast_serializer/configuration.rb

@@ -4,35 +4,26 @@ require 'json'
 
 module FastSerializer
   class Configuration
-
-    RubyVer = Struct.new(:major, :feature, :fix) do
-
-      def is_2_4_or_less
-        major == 2 && feature <= 4
-      end
-    end
-
-    attr_reader :coder, :ruby_ver
+    attr_reader :coder
     attr_accessor :strict
 
     def initialize
       @coder = JSON
       @strict = false
-      @ruby_ver = RubyVer.new(*RUBY_VERSION.split(".").map(&:to_i))
     end
 
     def coder=(obj)
-      if obj.respond_to?(:dump) && obj.respond_to?(:load)
-        @coder = obj
-      else
-        raise ArgumentError, "must respond to #load and #dump methods"
+      unless obj.respond_to?(:dump) && obj.respond_to?(:load)
+        raise ArgumentError, 'must respond to #load and #dump methods'
       end
+
+      @coder = obj
     end
   end
 
   class << self
     def config
-      @_config ||= Configuration.new
+      @config ||= Configuration.new
     end
 
     def configure(&block)

data/lib/fast_serializer/json_model/array.rb

@@ -3,6 +3,10 @@
 module FastSerializer
   module JsonModel
     class Array < Relationship
+      # @param resource [Object]
+      # @param params [Hash]
+      # @param context [Hash]
+      # @return [Array]
       def serialize(resources, params, context)
         return if resources.nil?
 

data/lib/fast_serializer/json_model/attribute.rb

@@ -11,8 +11,9 @@ module FastSerializer
                     :cond_method_name,
                     :injected
 
-      def initialize(_)
+      def initialize(*)
         super
+
         @mixin = nil
         @method_name = nil
         @injected = false
@@ -20,32 +21,8 @@ module FastSerializer
         @cond = nil
         @cond = @opts[:if] || @opts[:unless] || @cond
 
-        if method.is_a?(Proc)
-          @method_name = "__#{key}__"
-          @method_arity = method.arity.abs
-          @mixin = Module.new
-
-          if FastSerializer.config.ruby_ver.is_2_4_or_less
-            @mixin.redefine_method @method_name, &method
-          else
-            @mixin.define_method @method_name, &method
-          end
-
-        end
-
-        if !cond.nil? && cond.is_a?(Proc)
-          @cond_method_name = "__#{key}_cond__"
-          @cond_arity = cond.arity.abs
-          @mixin ||= Module.new
-
-          if FastSerializer.config.ruby_ver.is_2_4_or_less
-            @mixin.redefine_method @cond_method_name, &cond
-          else
-            @mixin.define_method @cond_method_name, &cond
-          end
-
-        end
-
+        init_with_proc if method.is_a?(Proc)
+        init_with_cond if !cond.nil? && cond.is_a?(Proc)
       end
 
       def injectable?
@@ -57,32 +34,39 @@ module FastSerializer
         self.injected = true
       end
 
+      # @param resource [Object]
+      # @param params [Hash]
+      # @param context [Hash]
+      # @return [Object]
       def serialize(resource, params, context)
+        can_execute_on_mixin = injected && !method_name.nil? && !context.nil?
 
-        val = if injected && !method_name.nil? && !context.nil?
-          call_method_on_context(context, method_name, method_arity, resource, params)
-
-        elsif method.is_a?(Proc)
-          call_proc_binding_to_context(context, method, method_arity, resource, params)
-
-        else
-          resource.public_send(method)
-        end
+        val = if can_execute_on_mixin
+                call_method_on_context(context, method_name, method_arity, resource, params)
+              elsif method.is_a?(Proc)
+                call_proc_binding_to_context(context, method, method_arity, resource, params)
+              else
+                resource.public_send(method)
+              end
 
         val.freeze
 
         val
       end
 
+      # @param resource [Object]
+      # @param params [Hash]
+      # @param context [Hash]
+      # @return [Boolean]
       def included?(resource, params, context)
         return true if cond.nil?
 
-        res = if injected && !cond_method_name.nil? && !context.nil?
-                call_method_on_context(context, cond_method_name, cond_arity, resource, params)
+        can_execute_on_mixin = injected && !cond_method_name.nil? && !context.nil?
 
+        res = if can_execute_on_mixin
+                call_method_on_context(context, cond_method_name, cond_arity, resource, params)
               elsif cond.is_a?(Proc)
                 call_proc_binding_to_context(context, cond, cond_arity, resource, params)
-
               else
                 context.public_send(cond)
               end
@@ -94,6 +78,30 @@ module FastSerializer
 
       private
 
+      def init_with_cond
+        @cond_method_name = "__#{key}_cond__"
+        @cond_arity = cond.arity.abs
+        @mixin ||= Module.new
+
+        if RUBY_VERSION <= '2.5.0'
+          @mixin.redefine_method @cond_method_name, &cond
+        else
+          @mixin.define_method @cond_method_name, &cond
+        end
+      end
+
+      def init_with_proc
+        @method_name = "__#{key}__"
+        @method_arity = method.arity.abs
+        @mixin = Module.new
+
+        if RUBY_VERSION <= '2.5.0'
+          @mixin.redefine_method @method_name, &method
+        else
+          @mixin.define_method @method_name, &method
+        end
+      end
+
       def call_proc_binding_to_context(context, prc, arity, resource, params)
         case arity
         when 1

data/lib/fast_serializer/json_model/has_many_relationship.rb

@@ -3,16 +3,18 @@
 module FastSerializer
   module JsonModel
     class HasManyRelationship < Relationship
-      def serialize(resource, params, context)
+      # @param resource [Object]
+      # @param params [Hash]
+      # @return [Array<Hash>]
+      def serialize(resource, params, _context)
         collection = resource.public_send(method)
         return if collection.nil?
 
         if @serializer_klass
           @serializer_klass.new(collection, params).serializable_hash
         elsif @schema
-          collection.map { |resource| @schema.serialize_resource(resource, params) }
+          collection.map { |entry| @schema.serialize_resource(entry, params) }
         end
-
       end
     end
   end

data/lib/fast_serializer/json_model/has_one_relationship.rb

@@ -3,7 +3,10 @@
 module FastSerializer
   module JsonModel
     class HasOneRelationship < Relationship
-      def serialize(resource, params, context)
+      # @param resource [Object]
+      # @param params [Hash]
+      # @return [Hash]
+      def serialize(resource, params, _)
         relation = resource.public_send(method)
 
         if @serializer_klass

data/lib/fast_serializer/json_model/node.rb

@@ -5,21 +5,25 @@ module FastSerializer
     class Node
       attr_accessor :key, :method, :context
 
+      # @param key [String]
+      # @param method [String]
+      # @param opts [Hash]
       def initialize(key: nil, method: nil, opts: {}, **_)
         @key = key&.to_sym
         @method = method || key
         @opts = opts || {}
       end
 
+      # @return [Boolean]
       def injectable?
         false
       end
 
-      def serialize(_resource, _params, context = nil)
+      def serialize(_resource, _params, _context = nil)
         raise NotImplementedError
       end
 
-      def included?(_resource, _params, context = nil)
+      def included?(_resource, _params, _context = nil)
         raise NotImplementedError
       end
     end

data/lib/fast_serializer/json_model/object.rb

@@ -10,23 +10,31 @@ module FastSerializer
         @attributes = {}
       end
 
+      # @param attribute [FastSerializer::JsonModel::Node]
       def add_attribute(attribute)
         attributes[attribute.key] = attribute
       end
 
+      # @param resource [Object]
+      # @param params [Hash]
+      # @param context [Hash]
+      # @return [Hash]
       def serialize(resource, params, context)
         return if resource.nil?
 
-        res = attributes.values.each_with_object({}) do |attribute, res|
-          next res unless attribute.included?(resource, params, context)
+        result = {}
+
+        attributes.each do |_, attribute|
+          next unless attribute.included?(resource, params, context)
 
           val = attribute.serialize(resource, params, context)
-          res[attribute.key] = val
+          result[attribute.key] = val
         end
 
-        res
+        result
       end
 
+      # @return [Boolean]
       def included?(*)
         true
       end

data/lib/fast_serializer/json_model/relationship.rb

@@ -5,32 +5,49 @@ module FastSerializer
     class Relationship < Attribute
       attr_accessor :serialization_schema
 
-      def initialize(key: nil, method: nil, opts: {}, serializer: nil, schema: nil, strict: false)
+      # @param serializer [FastSerializer::Schema::Mixin]
+      # @param schema [FastSerializer::Schema]
+      def initialize(serializer: nil, schema: nil, **)
         super
+
         @serializer_klass = serializer
         @schema = schema
 
-        raise ArgumentError, "must provide serializer or schema" if @serializer_klass.nil? && @schema.nil?
+        if @serializer_klass.nil? && @schema.nil?
+          raise ArgumentError, 'must provide serializer or schema'
+        end
       end
 
+      # @param resource [Object]
+      # @param params [Hash]
+      # @param context [Hash]
+      # @return [Boolean]
       def included?(resource, params, context)
         super && include_relation?(params)
       end
 
+      # @param params [Hash]
+      # @return [Boolean]
       def include_relation?(params)
         include?(params) && !exclude?(params)
       end
 
+      # @param params [Hash]
+      # @return [Boolean]
       def exclude?(params)
         return false if params[:exclude].nil?
         return false if params[:exclude].empty?
+
         params[:exclude_index].key?(key)
       end
 
+      # @param params [Hash]
+      # @return [Boolean]
       def include?(params)
         return true if params[:include].nil?
         return false if params[:include].empty?
-        params[:include_index].has_key?(key)
+
+        params[:include_index].key?(key)
       end
     end
   end

data/lib/fast_serializer/schema.rb

@@ -3,13 +3,9 @@
 require 'forwardable'
 
 module FastSerializer
-
   class Schema
-
     attr_reader :_root, :serialization_schema, :params, :strict
 
-    public
-
     def initialize(params = {}, root = nil, strict = nil)
       @root                   = root
       @strict                 = strict || FastSerializer.config.strict
@@ -24,79 +20,98 @@ module FastSerializer
     end
 
     def include=(list)
-      return if !list
+      return unless list
+      return if list.empty?
 
-      if list.any?
-        @params[:include]       = list.map(&:to_sym)
-        @params[:include_index] = @params[:include].map { |key| [key, nil] }.to_h
-      end
+      @params[:include]       = list.map(&:to_sym)
+      @params[:include_index] = @params[:include].map { |key| [key, nil] }.to_h
     end
 
     def exclude=(list)
-      return if !list
+      return unless list
+      return if list.empty?
 
-      if list.any?
-        @params[:exclude]       = list.map(&:to_sym)
-        @params[:exclude_index] = @params[:exclude].map { |key| [key, nil] }.to_h
-      end
+      @params[:exclude]       = list.map(&:to_sym)
+      @params[:exclude_index] = @params[:exclude].map { |key| [key, nil] }.to_h
     end
 
-    # @param [Array] attribute_names
+    # Defines a list of attributes for serialization
+    #
+    # @param attribute_names [Array<String, Symbol>] a list of attributes to serialize
+    # each of these attributes value is fetched calling a corresponding method from a resource instance
+    # passed to the serializer
     def attributes(*attribute_names)
       attribute_names.each do |attribute_name|
-        serialization_schema.add_attribute JsonModel::Attribute.new(
-          key:    attribute_name,
-          method: attribute_name,
+        serialization_schema.add_attribute(
+          JsonModel::Attribute.new(key: attribute_name, method: attribute_name)
         )
       end
     end
 
-    # @param [String] attribute_name
-    # @param [Hash] opts - attribute options
-    # @param [Proc] block - result is used as the attribute value
+    # Defines an attribute for serialization
+    #
+    # @param attribute_name [String, Symbol] an attribute name
+    # @param opts [Hash] attribute options
+    # @option opts [Proc] :if conditional clause. accepts a proc/lambda which has to return a boolean
+    # @option opts [Proc] :unless (see opts:if)
+    # @param block [Proc] result is used as the attribute value
+    #
     def attribute(attribute_name, opts = {}, &block)
-      serialization_schema.add_attribute JsonModel::Attribute.new(
-        key:    attribute_name,
-        method: block,
-        opts:   opts,
+      serialization_schema.add_attribute(
+        JsonModel::Attribute.new(
+          key: attribute_name,
+          method: block,
+          opts: opts
+        )
       )
     end
 
-    # @param [String] attribute_name
-    # @param [Hash] opts - attribute options
+    # Defines an attribute for serialization
+    #
+    # @param attribute_name [String, Symbol] an attribute name
+    # @param opts [Hash] attribute options
+    # @option opts [Proc] :if conditional clause. accepts a proc/lambda which has to return a boolean
+    # @option opts [Proc] :unless (see opts:if)
+    # @option opts [FastSerializer::Schema::Mixin, nil] :serializer a serializer class with injected  module or a inherited class
+    # @option opts [FastSerializer::Schema] :schema
+    #
     def has_one(attribute_name, opts = {})
       serialization_schema.add_attribute JsonModel::HasOneRelationship.new(
-        key:        opts.delete(:key) || attribute_name,
-        method:     opts.delete(:method) || attribute_name,
-        opts:       opts,
-        schema:     opts.delete(:schema),
-        serializer: opts.delete(:serializer),
+        key: opts.delete(:key) || attribute_name,
+        method: opts.delete(:method) || attribute_name,
+        opts: opts,
+        schema: opts.delete(:schema),
+        serializer: opts.delete(:serializer)
       )
     end
 
     alias belongs_to has_one
 
-    # @param [String] attribute_name
-    # @param [Hash] opts - attribute options
+    # @param attribute_name [String]
+    # @param opts [Hash] attribute options
     def has_many(attribute_name, opts = {})
-      serialization_schema.add_attribute JsonModel::HasManyRelationship.new(
-        key:        opts.delete(:key) || attribute_name,
-        method:     opts.delete(:method) || attribute_name,
-        opts:       opts,
-        schema:     opts.delete(:schema),
-        serializer: opts.delete(:serializer),
+      serialization_schema.add_attribute(
+        JsonModel::HasManyRelationship.new(
+          key: opts.delete(:key) || attribute_name,
+          method: opts.delete(:method) || attribute_name,
+          opts: opts,
+          schema: opts.delete(:schema),
+          serializer: opts.delete(:serializer)
+        )
       )
     end
 
     # @param [String] attribute_name
     # @param [Hash] opts - attribute options
     def list(attribute_name, opts = {})
-      serialization_schema.add_attribute JsonModel::Array.new(
-        key:        attribute_name,
-        method:     attribute_name,
-        opts:       opts,
-        schema:     opts.delete(:schema),
-        serializer: opts.delete(:serializer),
+      serialization_schema.add_attribute(
+        JsonModel::Array.new(
+          key: attribute_name,
+          method: attribute_name,
+          opts: opts,
+          schema: opts.delete(:schema),
+          serializer: opts.delete(:serializer)
+        )
       )
     end
 
@@ -116,11 +131,15 @@ module FastSerializer
     end
 
     def serialize_resource(resource, params = {}, context = self)
-      _params_dup = FastSerializer::Utils.symbolize_keys(self.params.merge(params))
+      Utils.ref_merge(self.params, params)
+      _params_dup = FastSerializer::Utils.symbolize_keys(self.params)
       meta        = _params_dup.delete(:meta)
 
-      is_collection = resource.respond_to?(:size) && !resource.respond_to?(:each_pair)
-      is_collection = params.delete(:is_collection) if params.has_key?(:is_collection)
+      is_collection = if params.key?(:is_collection)
+        params.delete(:is_collection)
+      else
+        resource.respond_to?(:size) && !resource.respond_to?(:each_pair)
+      end
 
       root = (_root || _params_dup.delete(:root))
 
@@ -139,7 +158,7 @@ module FastSerializer
 
             end
 
-      res  = { root => res } if root && !root.empty?
+      res = { root => res } if root && !root.empty?
 
       res[:meta] = meta if res.is_a?(Hash) && meta
 

data/lib/fast_serializer/schema/mixin.rb

@@ -1,12 +1,13 @@
+# frozen_string_literal: true
+
 module FastSerializer
   class Schema
     module Mixin
-
       module ClassMethods
         attr_accessor :__schema__, :__patched__
 
         def inherited(subclass)
-          subclass.__schema__ = self.__schema__.deep_copy
+          subclass.__schema__ = __schema__.deep_copy
         end
 
         def method_missing(method, *args, &block)
@@ -16,6 +17,18 @@ module FastSerializer
             super
           end
         end
+
+        def respond_to_missing?(method_name, include_private = false)
+          __schema__.respond_to?(method_name) || super
+        end
+
+        def __patch_with_attribute_definition
+          injectable_attributes = __schema__.serialization_schema.attributes.select { |_key, attribute| attribute.injectable? }
+          injectable_attributes.each { |_, attribute| attribute.inject(self) }
+          self.__patched__ = true
+
+          __patched__.freeze
+        end
       end
 
       module InstanceMethods
@@ -26,16 +39,14 @@ module FastSerializer
           self.params   = params || {}
         end
 
-        alias_method :object, :resource
+        alias object resource
 
         def serializable_hash(opts = {})
-          self.params = params.merge(opts)
+          Utils.ref_merge(params, opts)
+          self.params = params
 
-          if !self.class.__patched__
-            injectable_attributes = self.class.__schema__.serialization_schema.attributes.select { |key, attribute| attribute.injectable? }
-            injectable_attributes.each { |key, attribute| attribute.inject(self.class) }
-            self.class.__patched__ = true
-            self.class.__patched__.freeze
+          unless self.class.__patched__
+            self.class.__patch_with_attribute_definition
           end
 
           self.class.__schema__.serialize_resource(resource, params, self)
@@ -57,4 +68,4 @@ module FastSerializer
       end
     end
   end
-end
+end

data/lib/fast_serializer/utils.rb

@@ -1,9 +1,17 @@
+# frozen_string_literal: true
+
 module FastSerializer
   module Utils
     def self.symbolize_keys(hash)
       res = {}
-      hash.each { |key, _| res[key.to_sym] = hash[key] }
+      hash.each { |key, value| res[key.to_sym] = value }
       hash
     end
+
+    def self.ref_merge(hash_a, hash_b)
+      hash_b.each do |key, value|
+        hash_a[key] = value
+      end
+    end
   end
 end

data/lib/fast_serializer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module FastSerializer
-  VERSION = '0.6.0'
+  VERSION = '0.6.2'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fast_serializer_ruby
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.6.2
 platform: ruby
 authors:
 - Evgeny Stepanov
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-01 00:00:00.000000000 Z
+date: 2020-03-17 00:00:00.000000000 Z
 dependencies: []
 description: This library intends to solve such a typical and on the other hand important
   problem as efficient ruby object to hash transformation.
@@ -66,7 +66,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.4
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: fast_serializer is a lightweight ruby objects serializer.