fast_serializer 1.1.1 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9c038967d22d51bae0cd7f9993f625dbc3d1b747590ec3db6826cf4ac3c4c4ba
-  data.tar.gz: aeffd7e6274da8733f26556e6be03799fc182e05e8888245b4fe3a62df5c881c
+  metadata.gz: a7cb104ff4ece3439d2fcd7b6276866359a9ead6a511765fbef327d4bd33e168
+  data.tar.gz: dfff11c222e5cf0dc6352097fc3de8603f437fdc92636030c0aef4576b697445
 SHA512:
-  metadata.gz: 1d21207437c1ea463715ee99cd354de62c27a455df3f58b3ec56ed8b282276cdd1c6b632870750dbe2946d00aecd17e9457a12e1008e49d0d35cf500a05c973e
-  data.tar.gz: bf2888c605c80312f7fdfb457a258b86ac4c3b4810527e21b5e959c16aaec42933414fefb9121e15bde5a00a941c9cdb63b3d650070788f5712a6a73fac4976f
+  metadata.gz: 891c9cfde95aa08e4e2f73646f3cde78c4a1730673e9e74d518356dda869ff4848d1c9fc0d81bbcda936147faedd5e32775870a006e99679d34918f554252c70
+  data.tar.gz: 68814c806dd3b6a3b9e519b8ed5bf8c948ca2d12cb143a64a25c71aaac93690a66f5d85ea2ff71953d1bade1479f619b29c400ebab8137de947fb55053928d21

data/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## 1.1.3
+
+### Added
+- Optimize object shapes for the Ruby interpreter by declaring instance variables in constructors.
+
+## 1.1.2
+
+### Added
+- Sanity check for unsupported options
+
+### Fixed
+- Handle converting ActiveSupport::TimeWithZone to a Time so it can be better dumped to non-JSON formats.
+
+## 1.1.1
+
+### Added
+- Add `array` class method to serializers.
+
+## 1.1.0
+
+### Added
+- Add helper method for scope option.
+- Pass serialization options to child serializers.
+- Add `if` option to conditionally include fields.
+- Better cache keys handling for more complex objects.
+
+## 1.0.2
+
+### Added
+- Better integration with ActiveSupport caching.
+
+## 1.0.1
+
+### Fixed
+- Compatibility with change to fetch_multi in ActiveSupport 4.2.
+
+## 1.0.0
+
+### Added
+- Initial release

data/MIT_LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2016 We Heart It
+Copyright (c) 2016 Brian Durand
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,3 +1,7 @@
+[![Continuous Integration](https://github.com/bdurand/fast_serializer/actions/workflows/continuous_integration.yml/badge.svg)](https://github.com/bdurand/fast_serializer/actions/workflows/continuous_integration.yml)
+[![Regression Test](https://github.com/bdurand/fast_serializer/actions/workflows/regression_test.yml/badge.svg)](https://github.com/bdurand/fast_serializer/actions/workflows/regression_test.yml)
+[![Ruby Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://github.com/testdouble/standard)
+
 This gem provides a highly optimized framework for serializing Ruby objects into hashes suitable for serialization to some other format (i.e. JSON). It provides many of the same features as other serialization frameworks like active_model_serializers, but it is designed to emphasize code efficiency over feature set and syntactic surgar.
 
 ## Examples
@@ -229,7 +233,33 @@ You can also use the `array` helper class method on a serializer to do the same
 PersonSerializer.array([a, b, c, d])
 ```
 
-
 ## Performance
 
 Your mileage may vary. In many cases the performance of the serialization code doesn't particularly matter and this gem performs just about as well as other solutions. However, if you do have high throughput API or can utilize the caching features or have heavily nested models in your JSON responses, then the performance increase may be noticeable.
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'fast_serializer'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install fast_serializer
+```
+
+## Contributing
+
+Open a pull request on GitHub.
+
+Please use the [standardrb](https://github.com/testdouble/standard) syntax and lint your code with `standardrb --fix` before submitting.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/VERSION

@@ -1 +1 @@
-1.1.1
+1.1.3

data/fast_serializer.gemspec

@@ -1,24 +1,34 @@
-# coding: utf-8
-lib = File.expand_path('../lib', __FILE__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-
 Gem::Specification.new do |spec|
-  spec.name          = "fast_serializer"
-  spec.version       = File.read(File.expand_path("../VERSION", __FILE__)).chomp
-  spec.authors       = ["We Heart It", "Brian Durand"]
-  spec.email         = ["dev@weheartit.com", "bbdurand@gmail.com"]
-  spec.description   = %q{Super fast object serialization for API's combining a simple DSL with many optimizations under the hood.}
-  spec.summary       = %q{Super fast object serialization for API's.}
-  spec.homepage      = "https://github.com/weheartit/fast_serializer"
-  spec.license       = "MIT"
+  spec.name = "fast_serializer"
+  spec.version = File.read(File.expand_path("VERSION", __dir__)).strip
+  spec.authors = ["Brian Durand"]
+  spec.email = ["bbdurand@gmail.com"]
+
+  spec.summary = "Super fast object serialization for API's combining a simple DSL with many optimizations under the hood."
+  spec.homepage = "https://github.com/bdurand/fast_serializer"
+  spec.license = "MIT"
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  ignore_files = %w[
+    .
+    Appraisals
+    Gemfile
+    Gemfile.lock
+    Rakefile
+    bin/
+    gemfiles/
+    spec/
+  ]
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject { |f| ignore_files.any? { |path| f.start_with?(path) } }
+  end
 
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_development_dependency "bundler", "~>1.3"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~>3.0"
-  spec.add_development_dependency "active_support", ">=4.0"
+  spec.required_ruby_version = ">= 2.5"
+
+  spec.add_dependency("redis")
+
+  spec.add_development_dependency "bundler"
 end

data/lib/fast_serializer/array_serializer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FastSerializer
   # Serializer implementation for serializing an array of objects.
   # This class allows taking advantage of a single SerializationContext
@@ -8,9 +10,11 @@ module FastSerializer
     serialize :array
 
     def initialize(object, options = nil)
+      @_array = nil
       super(Array(object), options)
     end
 
+    # @return [String]
     def cache_key
       if option(:serializer)
         array.collect(&:cache_key)
@@ -19,6 +23,7 @@ module FastSerializer
       end
     end
 
+    # @return [Boolean]
     def cacheable?
       if option(:cacheable) || self.class.cacheable?
         true
@@ -29,6 +34,7 @@ module FastSerializer
       end
     end
 
+    # @return [Numeric, Boolean]
     def cache_ttl
       if option(:cache_ttl)
         true
@@ -39,6 +45,7 @@ module FastSerializer
       end
     end
 
+    # @return [FastSerializer::Cache, Boolean]
     def cache
       if option(:cache)
         true
@@ -49,6 +56,7 @@ module FastSerializer
       end
     end
 
+    # @return [Hash]
     def as_json(*args)
       if array.nil?
         nil
@@ -61,14 +69,14 @@ module FastSerializer
 
     undef :to_hash
     undef :to_h
-    alias :to_a :as_json
+    alias_method :to_a, :as_json
 
     protected
 
     def load_from_cache
       if cache
-        values = cache.fetch_all(array, cache_ttl){|serializer| serializer.as_json}
-        {:array => values}
+        values = cache.fetch_all(array, cache_ttl) { |serializer| serializer.as_json }
+        {array: values}
       else
         load_hash
       end
@@ -77,11 +85,11 @@ module FastSerializer
     private
 
     def array
-      unless defined?(@_array)
+      if @_array.nil?
         serializer = option(:serializer)
         if serializer
           serializer_options = option(:serializer_options)
-          @_array = object.collect{|obj| serializer.new(obj, serializer_options)}
+          @_array = object.collect { |obj| serializer.new(obj, serializer_options) }
         else
           @_array = object
         end

data/lib/fast_serializer/cache/active_support_cache.rb

@@ -1,22 +1,24 @@
+# frozen_string_literal: true
+
 module FastSerializer
   # ActiveSupport compatible cache implementation.
   class Cache::ActiveSupportCache < Cache
     attr_reader :cache
-    
+
     def initialize(cache)
       @cache = cache
     end
-    
+
     def fetch(serializer, ttl)
-      @cache.fetch(serializer.cache_key, :expires_in => ttl) do
+      @cache.fetch(serializer.cache_key, expires_in: ttl) do
         yield(serializer)
       end
     end
-    
+
     def fetch_all(serializers, ttl)
-      results = @cache.fetch_multi(*serializers){|serializer| yield(serializer)}
+      results = @cache.fetch_multi(*serializers) { |serializer| yield(serializer) }
       if results.is_a?(Hash)
-        serializers.collect{|serializer| results[serializer]}
+        serializers.collect { |serializer| results[serializer] }
       else
         results
       end

data/lib/fast_serializer/cache.rb

@@ -1,7 +1,16 @@
+# frozen_string_literal: true
+
 module FastSerializer
   # Base class for cache implementations for storing cacheable serializers.
   # Implementations must implement the +fetch+ method.
   class Cache
+    # Fetch a serialized value from the cache. If the value is not cached, the
+    # block will be yielded to to generate the value.
+    #
+    # @param serializer [FastSerializer::Serializer] The serializer to fetch the value for.
+    # @param ttl [Numeric] The time to live for the cached value.
+    # @yieldparam serializer [FastSerializer::Serializer] The serializer to generate the value for.
+    # @return [Object] The serialized value.
     def fetch(serializer, ttl, &block)
       raise NotImplementedError
     end
@@ -11,6 +20,11 @@ module FastSerializer
     # if the cache can return multiple values at once.
     #
     # The block to this method will be yielded to with each uncached serializer.
+    #
+    # @param serializers [Array<FastSerializer::Serializer>] The serializers to fetch the values for.
+    # @param ttl [Numeric] The time to live for the cached values.
+    # @yieldparam serializer [FastSerializer::Serializer] A serializer to generate the value for.
+    # @return [Array<Object>] The serialized values.
     def fetch_all(serializers, ttl)
       serializers.collect do |serializer|
         fetch(serializer, ttl) do

data/lib/fast_serializer/serialization_context.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FastSerializer
   # This class provides a context for creating serializers that allows
   # duplicate serializers to be re-used within the context. This then
@@ -7,6 +9,8 @@ module FastSerializer
       # Use a context or create one for use within a block. Any serializers
       # based on the same object with the same options within the block will be
       # re-used instead of creating duplicates.
+      #
+      # @return [Object] The return value of the block.
       def use
         if Thread.current[:fast_serializer_context]
           yield
@@ -21,6 +25,8 @@ module FastSerializer
       end
 
       # Return the current context or nil if none is in use.
+      #
+      # @return [FastSerializer::SerializationContext, nil]
       def current
         Thread.current[:fast_serializer_context]
       end
@@ -31,9 +37,14 @@ module FastSerializer
       @references = nil
     end
 
-    # Returns a serializer from the context cache if a duplicate has already
+    # Returns a serializer from the context cache if one has already
     # been created. Otherwise creates the serializer and adds it to the
     # cache.
+    #
+    # @param serializer_class [Class] The serializer class to create.
+    # @param object [Object] The object to serialize.
+    # @param options [Hash] The options to pass to the serializer.
+    # @return [FastSerializer::Serializer] The serializer.
     def load(serializer_class, object, options = nil)
       key = [serializer_class, object, options]
       serializer = nil
@@ -44,7 +55,7 @@ module FastSerializer
       unless serializer
         serializer = serializer_class.allocate
         serializer.send(:initialize, object, options)
-        @cache ||= {}
+        @cache = {}
         @cache[key] = serializer
       end
 
@@ -52,6 +63,10 @@ module FastSerializer
     end
 
     # Maintain reference stack to avoid circular references.
+    #
+    # @param object [Object] The object to check for circular references.
+    # @yield The block to execute.
+    # @return The return value of the block.
     def with_reference(object)
       if @references
         raise CircularReferenceError.new(object) if @references.include?(object)

data/lib/fast_serializer/serialized_field.rb

@@ -1,10 +1,20 @@
+# frozen_string_literal: true
+
 module FastSerializer
   # Data structure used internally for maintaining a field to be serialized.
   class SerializedField
     attr_reader :name, :condition
 
+    # Create a new serialized field.
+    #
+    # @param name [Symbol] the name of the field
+    # @param optional [Boolean] whether the field is optional
+    # @param serializer [Class] the serializer to use for the field
+    # @param serializer_options [Hash] the options to pass to the serializer
+    # @param enumerable [Boolean] whether the field is enumerable
+    # @param condition [Proc] a condition to determine whether the field should be serialized
     def initialize(name, optional: false, serializer: nil, serializer_options: nil, enumerable: false, condition: nil)
-      @name = name
+      @name = name.to_sym
       @optional = !!optional
       @condition = condition
       if serializer
@@ -14,22 +24,27 @@ module FastSerializer
       end
     end
 
+    # @return [Boolean] true if the field is optional
     def optional?
       @optional
     end
 
     # Wrap a value in the serializer if one has been set. Otherwise just returns the raw value.
+    #
+    # @param value [Object] the value to serialize
+    # @param options [Hash] the options to pass to the serializer
+    # @return [Object] the serialized value
     def serialize(value, options = nil)
       if value && @serializer
         serializer = nil
-        if @enumerable
-          serializer = ArraySerializer.new(value, :serializer => @serializer, :serializer_options => serializer_options(options))
+        serializer = if @enumerable
+          ArraySerializer.new(value, serializer: @serializer, serializer_options: serializer_options(options))
         else
-          serializer = @serializer.new(value, serializer_options(options))
+          @serializer.new(value, serializer_options(options))
         end
         context = SerializationContext.current
         if context
-          context.with_reference(value){ serializer.as_json }
+          context.with_reference(value) { serializer.as_json }
         else
           serializer.as_json
         end
@@ -56,10 +71,10 @@ module FastSerializer
       retval = {}
       merge_hash.each do |key, merge_value|
         value = hash[key]
-        if value.is_a?(Hash) && merge_value.is_a?(Hash)
-          retval[key] = deep_merge(value, merge_value)
+        retval[key] = if value.is_a?(Hash) && merge_value.is_a?(Hash)
+          deep_merge(value, merge_value)
         else
-          retval[key] = merge_value
+          merge_value
         end
       end
       retval
@@ -67,8 +82,14 @@ module FastSerializer
 
     # Convert the value to primitive data types: string, number, boolean, symbol, time, date, array, hash.
     def serialize_value(value)
-      if value.is_a?(String) || value.is_a?(Numeric) || value == nil || value == true || value == false || value.is_a?(Time) || value.is_a?(Date) || value.is_a?(Symbol)
+      if value.is_a?(String) || value.is_a?(Numeric) || value.nil? || value == true || value == false || value.is_a?(Symbol)
         value
+      elsif value.is_a?(Time) || value.is_a?(Date)
+        if defined?(ActiveSupport::TimeWithZone) && value.is_a?(ActiveSupport::TimeWithZone)
+          value.to_time
+        else
+          value
+        end
       elsif value.is_a?(Hash)
         serialize_hash(value)
       elsif value.is_a?(Enumerable)
@@ -89,7 +110,7 @@ module FastSerializer
       value.each do |k, v|
         val = serialize_value(v)
         if val.object_id != v.object_id
-          hash = value.dup unless hash
+          hash ||= value.dup
           hash[k] = val
         end
       end
@@ -101,7 +122,7 @@ module FastSerializer
       value.each_with_index do |v, i|
         val = serialize_value(v)
         if val.object_id != v.object_id
-          array = value.dup unless array
+          array ||= value.dup
           array[i] = val
         end
       end