fast_serializer 1.1.2 → 1.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 612f91c858c466052eb82d76560f4acb6bf55f416a2da7d104b0d3c97d40cddb
-  data.tar.gz: 7a515141fcad3e9ed626abd98bb67ce049b00a520a8a1d7e87e99245cfd397e1
+  metadata.gz: a7cb104ff4ece3439d2fcd7b6276866359a9ead6a511765fbef327d4bd33e168
+  data.tar.gz: dfff11c222e5cf0dc6352097fc3de8603f437fdc92636030c0aef4576b697445
 SHA512:
-  metadata.gz: b4dc18b54f002e692ed98c5977f14df1233bd10f71093222098c127412e0455a714f5182d1c8666a8d30915020849edaf61596305724d1437b5e96baf21b7eb4
-  data.tar.gz: 4636276312fcb0654cec728e93f35f717dc58c23960588716713c8589a52c5bc59e0b4b143a441199740c26d40d51a665f58ce6ccef599f87f31fd03efb94857
+  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,5 +1,6 @@
-[![Build Status](https://travis-ci.org/weheartit/fast_serializer.svg?branch=master)](https://travis-ci.org/weheartit/fast_serializer)
-[![Maintainability](https://api.codeclimate.com/v1/badges/02fd32c734e667432df6/maintainability)](https://codeclimate.com/github/bdurand/fast_serializer/maintainability)
+[![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.
 
@@ -232,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.2
+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", "~>2.0"
-  spec.add_development_dependency "rake"
-  spec.add_development_dependency "rspec", "~>3.0"
-  spec.add_development_dependency "activesupport", ">=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

@@ -10,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)
@@ -21,6 +23,7 @@ module FastSerializer
       end
     end
 
+    # @return [Boolean]
     def cacheable?
       if option(:cacheable) || self.class.cacheable?
         true
@@ -31,6 +34,7 @@ module FastSerializer
       end
     end
 
+    # @return [Numeric, Boolean]
     def cache_ttl
       if option(:cache_ttl)
         true
@@ -41,6 +45,7 @@ module FastSerializer
       end
     end
 
+    # @return [FastSerializer::Cache, Boolean]
     def cache
       if option(:cache)
         true
@@ -51,6 +56,7 @@ module FastSerializer
       end
     end
 
+    # @return [Hash]
     def as_json(*args)
       if array.nil?
         nil
@@ -63,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
@@ -79,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

@@ -4,21 +4,21 @@ 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

@@ -4,6 +4,13 @@ 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
@@ -13,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

@@ -9,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
@@ -23,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
@@ -33,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
@@ -46,7 +55,7 @@ module FastSerializer
       unless serializer
         serializer = serializer_class.allocate
         serializer.send(:initialize, object, options)
-        @cache ||= {}
+        @cache = {}
         @cache[key] = serializer
       end
 
@@ -54,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

@@ -5,8 +5,16 @@ module FastSerializer
   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
@@ -16,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
@@ -58,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
@@ -69,7 +82,7 @@ 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?(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)
@@ -97,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
@@ -109,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

data/lib/fast_serializer/serializer.rb

@@ -57,7 +57,6 @@ module FastSerializer
   #
   # Serializing a nil object will result in nil rather than an empty hash.
   module Serializer
-
     def self.included(base)
       base.extend(ClassMethods)
       base.extend(ArrayHelper) unless base.is_a?(FastSerializer::ArraySerializer)
@@ -102,6 +101,10 @@ module FastSerializer
       #
       # Subclasses will inherit all of their parent classes serialized fields. Subclasses can override fields
       # defined on the parent class by simply defining them again.
+      #
+      # @param fields [Array<Symbol, Hash>] the fields to serialize. If the last argument is a hash, it will be
+      #   treated as options for the serialized fields.
+      # @return [void]
       def serialize(*fields)
         options = {}
         if fields.size > 1 && fields.last.is_a?(Hash)
@@ -119,7 +122,7 @@ module FastSerializer
         condition = options.delete(:if)
 
         unless options.empty?
-          raise ArgumentError.new("Unsupported serialize options: #{options.keys.join(', ')}")
+          raise ArgumentError.new("Unsupported serialize options: #{options.keys.join(", ")}")
         end
 
         if as && fields.size > 1
@@ -128,8 +131,8 @@ module FastSerializer
 
         fields.each do |field|
           name = as
-          if name.nil? && field.to_s.end_with?("?".freeze)
-            name = field.to_s.chomp("?".freeze)
+          if name.nil? && field.to_s.end_with?("?")
+            name = field.to_s.chomp("?")
           end
 
           field = field.to_sym
@@ -144,6 +147,8 @@ module FastSerializer
 
       # Remove a field from being serialized. This can be useful in subclasses if they need to remove a
       # field defined by the parent class.
+      #
+      # @param fields [Array<Symbol>] the fields to remove
       def remove(*fields)
         remove_fields = fields.collect(&:to_sym)
         field_list = []
@@ -161,6 +166,10 @@ module FastSerializer
       #
       # You can also specify the cache time to live (ttl) in seconds and the cache implementation to use.
       # Both of these values are inherited on subclasses.
+      #
+      # @param cacheable [Boolean] pass false if the serializer is not cacheable
+      # @param ttl [Numeric] the time to live in seconds for a cacheable serializer
+      # @param cache [FastSerializer::Cache] the cache implementation to use for a cacheable serializer
       def cacheable(cacheable = true, ttl: nil, cache: nil)
         @cacheable = cacheable
         self.cache_ttl = ttl if ttl
@@ -168,6 +177,8 @@ module FastSerializer
       end
 
       # Return true if the serializer class is cacheable.
+      #
+      # @return [Boolean]
       def cacheable?
         unless defined?(@cacheable)
           @cacheable = superclass.cacheable? if superclass.respond_to?(:cacheable?)
@@ -176,22 +187,27 @@ module FastSerializer
       end
 
       # Return the time to live in seconds for a cacheable serializer.
+      #
+      # @return [Numeric]
       def cache_ttl
         if defined?(@cache_ttl)
           @cache_ttl
         elsif superclass.respond_to?(:cache_ttl)
           superclass.cache_ttl
-        else
-          nil
         end
       end
 
       # Set the time to live on a cacheable serializer.
+      #
+      # @param value [Numeric] the time to live in seconds
+      # @return [void]
       def cache_ttl=(value)
         @cache_ttl = value
       end
 
       # Get the cache implemtation used to store cacheable serializers.
+      #
+      # @return [FastSerializer::Cache]
       def cache
         if defined?(@cache)
           @cache
@@ -203,6 +219,9 @@ module FastSerializer
       end
 
       # Set the cache implementation used to store cacheable serializers.
+      #
+      # @param cache [FastSerializer::Cache]
+      # @return [void]
       def cache=(cache)
         if defined?(ActiveSupport::Cache::Store) && cache.is_a?(ActiveSupport::Cache::Store)
           cache = Cache::ActiveSupportCache.new(cache)
@@ -222,6 +241,8 @@ module FastSerializer
       end
 
       # Return a list of the SerializedFields defined for the class.
+      #
+      # @return [Array<FastSerializer::SerializedField>]
       def serializable_fields
         unless defined?(@serializable_fields) && @serializable_fields
           fields = superclass.send(:serializable_fields).dup if superclass.respond_to?(:serializable_fields)
@@ -249,10 +270,10 @@ module FastSerializer
         field_list = []
         added = false
         serializable_fields.each do |existing_field|
-          if existing_field.name == name
-            field_list << field
+          field_list << if existing_field.name == name
+            field
           else
-            field_list << existing_field
+            existing_field
           end
         end
         field_list << field unless added
@@ -261,14 +282,14 @@ module FastSerializer
 
       # Define a delegate method name +attribute+ that invokes the +field+ method on the wrapped object.
       def define_delegate(attribute, field)
-        define_method(attribute){ object.send(field) }
+        define_method(attribute) { object.send(field) }
       end
     end
 
     module ArrayHelper
       # Helper method to serialize an array of values using this serializer.
       def array(values, options = nil)
-        options = (options ? options.merge(:serializer => self) : {:serializer => self})
+        options = (options ? options.merge(serializer: self) : {serializer: self})
         FastSerializer::ArraySerializer.new(values, options)
       end
     end
@@ -295,14 +316,12 @@ module FastSerializer
     # Serialize the wrapped object into a format suitable for passing to a JSON parser.
     def as_json(*args)
       return nil unless object
-      unless @_serialized
-        @_serialized = (cacheable? ? load_from_cache : load_hash).freeze
-      end
+      @_serialized ||= (cacheable? ? load_from_cache : load_hash).freeze
       @_serialized
     end
 
-    alias :to_hash :as_json
-    alias :to_h :as_json
+    alias_method :to_hash, :as_json
+    alias_method :to_h, :as_json
 
     # Convert the wrapped object to JSON format.
     def to_json(options = {})
@@ -363,7 +382,7 @@ module FastSerializer
           name = field.name
 
           if field.optional?
-            next unless include_fields && include_fields.include?(name)
+            next unless include_fields&.include?(name)
           end
           next if excluded_fields && excluded_fields[name] == true
           condition = field.condition
@@ -419,7 +438,7 @@ module FastSerializer
         end
         hash_key
       elsif options.is_a?(Enumerable)
-        options.collect{|option| options_cache_key(option)}
+        options.collect { |option| options_cache_key(option) }
       else
         options
       end

data/lib/fast_serializer.rb

@@ -1,24 +1,22 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'time'
-require 'date'
+require "json"
+require "time"
+require "date"
 
 module FastSerializer
-  require_relative 'fast_serializer/cache'
-  require_relative 'fast_serializer/cache/active_support_cache'
-  require_relative 'fast_serializer/serialization_context'
-  require_relative 'fast_serializer/serialized_field'
-  require_relative 'fast_serializer/serializer'
-  require_relative 'fast_serializer/array_serializer'
+  require_relative "fast_serializer/cache"
+  require_relative "fast_serializer/cache/active_support_cache"
+  require_relative "fast_serializer/serialization_context"
+  require_relative "fast_serializer/serialized_field"
+  require_relative "fast_serializer/serializer"
+  require_relative "fast_serializer/array_serializer"
 
   class << self
     @cache = nil
 
     # Get the global cache implementation used for storing cacheable serializers.
-    def cache
-      @cache
-    end
+    attr_reader :cache
 
     # Set the global cache implementation used for storing cacheable serializers.
     # The cache implementation should implement the +fetch+ method as defined in
@@ -26,6 +24,8 @@ module FastSerializer
     #
     # In a Rails app, you can initialize the cache by simply passing in the value :rails
     # to use the default Rails.cache. You can also directly pass in an ActiveSupportCache::Store.
+    #
+    # @param cache [FastSerializer::Cache, ActiveSupport::Cache::Store, Symbol] the cache to use
     def cache=(cache)
       if cache == :rails
         cache = Cache::ActiveSupportCache.new(Rails.cache)