fast_serializer 1.0.1 → 1.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 476d327b3e3f93b51fa1e27425a9617d43335292
-  data.tar.gz: b589d9d3834f931a694511d4d353bb4cfd005c4a
+SHA256:
+  metadata.gz: 9aa9a0f0945690089e7b2811fc8a7a2bd7d5d391a44d6ffd5da46fde8cde178a
+  data.tar.gz: 5c7767c57d03ec466b8b0b8a241ecaaf1190b04115db5bbe63a04884e302320e
 SHA512:
-  metadata.gz: e16e1f88ab40764e761d905435c45622ad4388945a97daddf5138b6a1dc4a544f43a49e6d357b99ece70bcfe7f3af7b328dce71d7062be3cea2ac565c90b2424
-  data.tar.gz: 785755326eda08ccb27a4d758f7ddc6c0783229fecab2e9029362af1375a5e21deb43feec983aa3698b7672f61e308f3794be3051aa960392941078d87043d54
+  metadata.gz: 6b385a08ca0c432e8f8660e19f95ad0f33b43372084dcd9910a10410f3f7cd168158e1138bfae101a76a216e210b50dfdea7a8207864182ab96ef65f099cef53
+  data.tar.gz: 3b39610d1a17bece32360aac268b5fd508e0fe46bb2fd2b29fa22f6e422e93fa2c8ae7b11bdd926f848b30e8c40f68d508e6ffe57c04eeea8cbbeb77e06fcceb

data/HISTORY.md

@@ -0,0 +1,11 @@
+### 1.0.2
+
+* Better integration with ActiveSupport caching.
+
+### 1.0.1
+
+* Compatibility with change to fetch_multi in ActiveSupport 4.2.
+
+### 1.0.0
+
+* Initial release

data/README.md

@@ -7,7 +7,7 @@ For these examples we'll assume we have a simple Person class.
 ```ruby
 class Person
   attr_accessor :id, :first_name, :last_name, :parents, :children
-  
+
   def intitialize(attributes = {})
     @id = attributes[:id]
     @first_name = attributes[:first_name]
@@ -16,7 +16,7 @@ class Person
     @parent = attributes[:parents]
     @children = attributes[:children] || {}
   end
-  
+
   def ==(other)
     other.instance_of?(self.class) && other.id == id
   end
@@ -31,7 +31,7 @@ ruby```
 class PersonSerializer
   include FastSerializer::Serializer
   serialize :id, :name
-  
+
   def name
     "#{object.first_name} #{object.last_name}"
   end
@@ -47,7 +47,7 @@ class PersonSerializer
   include FastSerializer::Serializer
   serialize :id, as: :person_id
   serialize :name, :delegate => false
-  
+
   def name
     "#{object.first_name} #{object.last_name}"
   end
@@ -65,7 +65,7 @@ class PersonSerializer
   serialize :name, :delegate => false
   serialize :parent, serializer: PersonSerializer
   serialize :children, serializer: PersonSerializer, enumerable: true
-  
+
   def name
     "#{object.first_name} #{object.last_name}"
   end
@@ -81,6 +81,8 @@ PersonSerializer.new(person).as_json # => {
                                      #    }
 ```
 
+### Optional and excluding fields
+
 Serializer can have optional fields. You can also specify fields to exclude.
 
 ```ruby
@@ -89,7 +91,7 @@ class PersonSerializer
   serialize :id
   serialize :name, :delegate => false
   serialize :gender, optional: true
-  
+
   def name
     "#{object.first_name} #{object.last_name}"
   end
@@ -100,6 +102,8 @@ PersonSerializer.new(person, :include => [:gender]).as_json # => {:id => 1, :nam
 PersonSerializer.new(person, :exclude => [:id]).as_json # => {:name => "John Doe"}
 ```
 
+### Serializer options
+
 You can specify custom options that control how the object is serialized.
 
 ```ruby
@@ -107,7 +111,7 @@ class PersonSerializer
   include FastSerializer::Serializer
   serialize :id
   serialize :name, :delegate => false
-  
+
   def name
     if option(:last_first)
       "#{object.last_name}, #{object.first_name}"
@@ -118,9 +122,11 @@ class PersonSerializer
 end
 
 PersonSerializer.new(person).as_json # => {:id => 1, :name => "John Doe"}
-PersonSerializer.new(person, :last_first).as_json # => {:id => 1, :name => "Doe, John"}
+PersonSerializer.new(person, :last_first => true).as_json # => {:id => 1, :name => "Doe, John"}
 ```
 
+### Caching
+
 You can make serializers cacheable so that the serialized value can be stored and fetched from a cache.
 
 ```ruby
@@ -128,9 +134,9 @@ class PersonSerializer
   include FastSerializer::Serializer
   serialize :id
   serialize :name, :delegate => false
-  
+
   cacheable true, ttl: 60
-  
+
   def name
     if option(:last_first)
       "#{object.last_name}, #{object.first_name}"
@@ -143,6 +149,21 @@ end
 FastSerializer.cache = MyCache.new # Must be an implementation of FastSerializer::Cache
 ```
 
+For Rails application, you can run this in an initializer to tell `FastSerializer` to use `Rails.cache`
+
+```ruby
+FastSerializer.cache = :rails
+```
+
+You can also pass a cache to a serializer using the `:cache` option.
+
+### Collections
+
+If you have a collection of objects to serialize, you can use the `FastSerializer::ArraySerializer` to serialize an enumeration of objects.
+
+```ruby
+```
+
 ## 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.

data/VERSION

@@ -1 +1 @@
-1.0.1
+1.0.2

data/fast_serializer.gemspec

@@ -20,4 +20,5 @@ Gem::Specification.new do |spec|
   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"
 end

data/lib/fast_serializer.rb

@@ -9,25 +9,34 @@ module FastSerializer
   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 if defined?(@cache)
+      @cache
     end
-  
+
     # Set the global cache implementation used for storing cacheable serializers.
-    # The cache implementation should implement the +fetch+ method as defined in 
+    # The cache implementation should implement the +fetch+ method as defined in
     # FastSerializer::Cache. By default no cache is set so caching won't do anything.
     #
     # In a Rails app, you can initialize the cache by simply passing in the value :rails
-    # to use the default Rails.cache.
+    # to use the default Rails.cache. You can also directly pass in an ActiveSupportCache::Store.
     def cache=(cache)
-      cache = Cache::ActiveSupportCache.new(Rails.cache) if cache == :rails
+      if cache == :rails
+        cache = Cache::ActiveSupportCache.new(Rails.cache)
+      elsif defined?(ActiveSupport::Cache::Store) && cache.is_a?(ActiveSupport::Cache::Store)
+        cache = Cache::ActiveSupportCache.new(cache)
+      end
+      if cache && !cache.is_a?(FastSerializer::Cache)
+        raise ArgumentError.new("The cache must be a FastSerializer::Cache or ActiveSupport::Cache::Store")
+      end
       @cache = cache
     end
   end
-  
+
   # Exception raised when there is a circular reference serializing a model dependent on itself.
   class CircularReferenceError < StandardError
     def initialize(model)

data/lib/fast_serializer/array_serializer.rb

@@ -4,13 +4,13 @@ module FastSerializer
   # for caching duplicate serializers.
   class ArraySerializer
     include Serializer
-    
+
     serialize :array
-    
+
     def initialize(object, options = nil)
       super(Array(object), options)
     end
-    
+
     def cache_key
       if option(:serializer)
         array.collect(&:cache_key)
@@ -18,7 +18,7 @@ module FastSerializer
         super
       end
     end
-    
+
     def cacheable?
       if option(:cacheable) || self.class.cacheable?
         true
@@ -28,7 +28,7 @@ module FastSerializer
         super
       end
     end
-    
+
     def cache_ttl
       if option(:cache_ttl)
         true
@@ -38,7 +38,7 @@ module FastSerializer
         super
       end
     end
-    
+
     def cache
       if option(:cache)
         true
@@ -48,7 +48,7 @@ module FastSerializer
         super
       end
     end
-    
+
     def as_json(*args)
       if array.nil?
         nil
@@ -58,13 +58,13 @@ module FastSerializer
         super[:array]
       end
     end
-    
+
     undef :to_hash
     undef :to_h
     alias :to_a :as_json
-    
+
     protected
-    
+
     def load_from_cache
       if cache
         values = cache.fetch_all(array, cache_ttl){|serializer| serializer.as_json}
@@ -73,9 +73,9 @@ module FastSerializer
         load_hash
       end
     end
-    
+
     private
-    
+
     def array
       unless defined?(@_array)
         serializer = option(:serializer)

data/lib/fast_serializer/cache.rb

@@ -5,11 +5,11 @@ module FastSerializer
     def fetch(serializer, ttl, &block)
       raise NotImplementedError
     end
-    
+
     # Fetch multiple serializers from the cache. The default behavior is just
     # to call +fetch+ with each serializer. Implementations may optimize this
     # if the cache can return multiple values at once.
-    # 
+    #
     # The block to this method will be yielded to with each uncached serializer.
     def fetch_all(serializers, ttl)
       serializers.collect do |serializer|

data/lib/fast_serializer/cache/active_support_cache.rb

@@ -7,9 +7,10 @@ module FastSerializer
       @cache = cache
     end
     
-    def fetch(serializer, ttl, &block)
-      exists = !!@cache.read(serializer.cache_key)
-      @cache.fetch(serializer.cache_key, :expires_in => ttl, &block)
+    def fetch(serializer, ttl)
+      @cache.fetch(serializer.cache_key, :expires_in => ttl) do
+        yield(serializer)
+      end
     end
     
     def fetch_all(serializers, ttl)

data/lib/fast_serializer/serialization_context.rb

@@ -19,18 +19,18 @@ module FastSerializer
           end
         end
       end
-      
+
       # Return the current context or nil if none is in use.
       def current
         Thread.current[:fast_serializer_context]
       end
     end
-    
+
     def initialize
       @cache = nil
       @references = nil
     end
-    
+
     # Returns a serializer from the context cache if a duplicate has already
     # been created. Otherwise creates the serializer and adds it to the
     # cache.
@@ -40,17 +40,17 @@ module FastSerializer
       if @cache
         serializer = @cache[key]
       end
-      
+
       unless serializer
         serializer = serializer_class.allocate
         serializer.send(:initialize, object, options)
         @cache ||= {}
         @cache[key] = serializer
       end
-      
+
       serializer
     end
-    
+
     # Maintain reference stack to avoid circular references.
     def with_reference(object)
       if @references
@@ -58,7 +58,7 @@ module FastSerializer
       else
         @references = []
       end
-      
+
       begin
         @references.push(object)
         yield

data/lib/fast_serializer/serialized_field.rb

@@ -2,7 +2,7 @@ module FastSerializer
   # Data structure used internally for maintaining a field to be serialized.
   class SerializedField
     attr_reader :name
-  
+
     def initialize(name, optional: false, serializer: nil, serializer_options: nil, enumerable: false)
       @name = name
       @optional = !!optional
@@ -12,11 +12,11 @@ module FastSerializer
         @enumerable = enumerable
       end
     end
-  
+
     def optional?
       @optional
     end
-    
+
     # Wrap a value in the serializer if one has been set. Otherwise just returns the raw value.
     def serialize(value)
       if value && @serializer
@@ -36,9 +36,9 @@ module FastSerializer
         serialize_value(value)
       end
     end
-    
+
     private
-    
+
     # 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)
@@ -73,6 +73,6 @@ module FastSerializer
         value
       end
     end
-    
+
   end
 end

data/lib/fast_serializer/serializer.rb

@@ -55,17 +55,17 @@ module FastSerializer
   #
   # Serializing a nil object will result in nil rather than an empty hash.
   module Serializer
-      
+
     def self.included(base)
       base.extend(ClassMethods)
     end
-    
+
     # Return the wrapped object that is being serialized.
     attr_reader :object
-    
+
     # Return the options hash (if any) that specified optional details about how to serialize the object.
     attr_reader :options
-    
+
     module ClassMethods
       # Define one or more fields to include in the serialized object. Field values will be gotten
       # by calling the method of the same name on class including this module.
@@ -100,23 +100,23 @@ module FastSerializer
         if as && fields.size > 1
           raise ArgumentError.new("Cannot specify :as argument with multiple fields to serialize")
         end
-        
+
         fields.each do |field|
           name = as
           if name.nil? && field.to_s.end_with?("?".freeze)
             name = field.to_s.chomp("?".freeze)
           end
-          
+
           field = field.to_sym
           attribute = (name || field).to_sym
           add_field(attribute, optional: optional, serializer: serializer, serializer_options: serializer_options, enumerable: enumerable)
-          
+
           if delegate && !method_defined?(attribute)
             define_delegate(attribute, field)
           end
         end
       end
-      
+
       # Remove a field from being serialized. This can be useful in subclasses if they need to remove a
       # field defined by the parent class.
       def remove(*fields)
@@ -127,11 +127,11 @@ module FastSerializer
         end
         @serializable_fields = field_list.freeze
       end
-      
+
       # Specify the cacheability of the serializer.
       #
       # You can specify the cacheable state (defaults to true) of the class. Subclasses will inherit the
-      # cacheable state of their parent class, so if you have non-cacheable serializer subclassing a 
+      # cacheable state of their parent class, so if you have non-cacheable serializer subclassing a
       # cacheable parent class, you can call <tt>cacheable false</tt> to override the parent behavior.
       #
       # You can also specify the cache time to live (ttl) in seconds and the cache implementation to use.
@@ -141,7 +141,7 @@ module FastSerializer
         self.cache_ttl = ttl if ttl
         self.cache = cache if cache
       end
-      
+
       # Return true if the serializer class is cacheable.
       def cacheable?
         unless defined?(@cacheable)
@@ -149,7 +149,7 @@ module FastSerializer
         end
         !!@cacheable
       end
-      
+
       # Return the time to live in seconds for a cacheable serializer.
       def cache_ttl
         if defined?(@cache_ttl)
@@ -160,12 +160,12 @@ module FastSerializer
           nil
         end
       end
-      
+
       # Set the time to live on a cacheable serializer.
       def cache_ttl=(value)
         @cache_ttl = value
       end
-      
+
       # Get the cache implemtation used to store cacheable serializers.
       def cache
         if defined?(@cache)
@@ -176,12 +176,15 @@ module FastSerializer
           FastSerializer.cache
         end
       end
-      
+
       # Set the cache implementation used to store cacheable serializers.
       def cache=(cache)
+        if defined?(ActiveSupport::Cache::Store) && cache.is_a?(ActiveSupport::Cache::Store)
+          cache = Cache::ActiveSupportCache.new(cache)
+        end
         @cache = cache
       end
-      
+
       # :nodoc:
       def new(object, options = nil)
         context = SerializationContext.current
@@ -192,7 +195,7 @@ module FastSerializer
           super
         end
       end
-      
+
       # Return a list of the SerializedFields defined for the class.
       def serializable_fields
         unless defined?(@serializable_fields) && @serializable_fields
@@ -202,14 +205,14 @@ module FastSerializer
         end
         @serializable_fields
       end
-      
+
       private
-      
+
       # Add a field to be serialized.
       def add_field(name, optional:, serializer:, serializer_options:, enumerable:)
         name = name.to_sym
         field = SerializedField.new(name, optional: optional, serializer: serializer, serializer_options: serializer_options, enumerable: enumerable)
-        
+
         # Add the field to the frozen list of fields.
         field_list = []
         added = false
@@ -223,13 +226,13 @@ module FastSerializer
         field_list << field unless added
         @serializable_fields = field_list.freeze
       end
-      
+
       # 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
-  
+
     # Create a new serializer for the specified object.
     #
     # Options can be passed in to control how the object is serialized. Options supported by all Serializers:
@@ -242,9 +245,13 @@ module FastSerializer
     def initialize(object, options = nil)
       @object = object
       @options = options
+      @cache = options[:cache] if options
+      if @cache && defined?(ActiveSupport::Cache::Store) && cache.is_a?(ActiveSupport::Cache::Store)
+        @cache = Cache::ActiveSupportCache.new(@cache)
+      end
       @_serialized = nil
     end
-  
+
     # Serialize the wrapped object into a format suitable for passing to a JSON parser.
     def as_json(*args)
       return nil unless object
@@ -253,54 +260,54 @@ module FastSerializer
       end
       @_serialized
     end
-    
+
     alias :to_hash :as_json
     alias :to_h :as_json
-    
+
     # Convert the wrapped object to JSON format.
-    def to_json(options = nil)
+    def to_json(options = {})
       if defined?(MultiJson)
-        MultiJson.dump(as_json)
+        MultiJson.dump(as_json, options)
       else
         JSON.dump(as_json)
       end
     end
-    
+
     # Fetch the specified option from the options hash.
     def option(name)
       @options[name] if @options
     end
-    
+
     # Return true if this serializer is cacheable.
     def cacheable?
       option(:cacheable) || self.class.cacheable?
     end
-    
+
     # Return the cache implementation where this serializer can be stored.
     def cache
-      option(:cache) || self.class.cache
+      @cache || self.class.cache
     end
-    
+
     # Return the time to live in seconds this serializer can be cached for.
     def cache_ttl
       option(:cache_ttl) || self.class.cache_ttl
     end
-    
+
     # Returns a array of the elements that make this serializer unique. The
     # key is an array made up of the serializer class name, wrapped object, and
     # serialization options hash.
     def cache_key
       [self.class.name, object, options]
     end
-    
+
     # :nodoc:
     def ==(other)
       other.instance_of?(self.class) && @object == other.object && @options == other.options
     end
     alias_method :eql?, :==
-    
+
     protected
-    
+
     # Load the hash that will represent the wrapped object as a serialized object.
     def load_hash
       hash = {}
@@ -319,7 +326,7 @@ module FastSerializer
       end
       hash
     end
-    
+
     # Load the hash that will represent the wrapped object as a serialized object from a cache.
     def load_from_cache
       if cache
@@ -330,9 +337,9 @@ module FastSerializer
         load_hash
       end
     end
-    
+
     private
-    
+
     # Return a list of optional fields to be included in the output from the :include option.
     def included_optional_fields
       included_fields = option(:include)
@@ -342,7 +349,7 @@ module FastSerializer
         nil
       end
     end
-    
+
     # Return a list of fields to be excluded from the output from the :exclude option.
     def excluded_regular_fields
       excluded_fields = option(:exclude)

data/spec/array_serializer_spec.rb

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
 describe FastSerializer::ArraySerializer do
-  
+
   it "should serialize an array of regular objects" do
     array = [1, 2, 3]
     serializer = FastSerializer::ArraySerializer.new(array)
     expect(serializer.as_json).to eq array
   end
-  
+
   it "should serialize any Enumerable" do
     hash = {:a => 1, :b => 2}
     serializer = FastSerializer::ArraySerializer.new(hash)
     expect(serializer.as_json).to eq hash.to_a
   end
-  
+
   it "should serializer an array of objects using a specific serializer" do
     model_1 = SimpleModel.new(:id => 1, :name => "foo")
     model_2 = SimpleModel.new(:id => 2, :name => "bar")
@@ -23,7 +23,7 @@ describe FastSerializer::ArraySerializer do
       {"id" => 2, "name" => "bar", "validated" => false}
     ]
   end
-  
+
   it "should serializer an array of objects using a specific serializer with options" do
     model_1 = SimpleModel.new(:id => 1, :name => "foo")
     model_2 = SimpleModel.new(:id => 2, :name => "bar")
@@ -33,20 +33,20 @@ describe FastSerializer::ArraySerializer do
       {"id" => 2, "name" => "bar", "validated" => false, "description" => nil}
     ]
   end
-  
+
   it "should not respond to_hash methods" do
     array = [1, 2, 3]
     serializer = FastSerializer::ArraySerializer.new(array)
     expect(serializer.respond_to?(:to_hash)).to eq false
     expect(serializer.respond_to?(:to_h)).to eq false
   end
-  
+
   it "should respond to to_a" do
     array = [1, 2, 3]
     serializer = FastSerializer::ArraySerializer.new(array)
     expect(serializer.to_a).to eq array
   end
-  
+
   it "should pull cacheable serializers from a cache" do
     model_1 = SimpleModel.new(:id => 1, :name => "foo")
     model_2 = SimpleModel.new(:id => 2, :name => "bar")

data/spec/cache/active_support_cache_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe FastSerializer::Cache::ActiveSupportCache do
+
+  it "should fetch from an ActiveSupport cache store" do
+    cache_store = ActiveSupport::Cache::MemoryStore.new
+    cache = FastSerializer::Cache::ActiveSupportCache.new(cache_store)
+    serializer = SimpleSerializer.new(SimpleModel.new(:id => 1))
+
+    expect(cache.fetch(serializer, 60){|s| s.as_json} ).to eq serializer.as_json
+    expect(cache.fetch(serializer, 60){ raise "boom" }).to eq serializer.as_json
+  end
+
+  it "should fetch multiple from an ActiveSupport cache store" do
+    cache_store = ActiveSupport::Cache::MemoryStore.new
+    cache = FastSerializer::Cache::ActiveSupportCache.new(cache_store)
+    s1 = SimpleSerializer.new(SimpleModel.new(:id => 1))
+    s2 = SimpleSerializer.new(SimpleModel.new(:id => 2))
+
+    expect(cache.fetch_all([s1, s2], 60){|s| s.as_json} ).to eq [s1.as_json, s2.as_json]
+    expect(cache.fetch_all([s1, s2], 60){ raise "boom" }).to eq [s1.as_json, s2.as_json]
+  end
+
+end

data/spec/fast_serializer_spec.rb

@@ -1,18 +1,19 @@
 require 'spec_helper'
 
 describe FastSerializer do
-  
+
   it "should be able to set and get a global cache" do
     expect(FastSerializer.cache).to eq nil
     begin
-      FastSerializer.cache = :mock
-      expect(FastSerializer.cache).to eq :mock
+      cache = TestCache.new
+      FastSerializer.cache = cache
+      expect(FastSerializer.cache).to eq cache
     ensure
       FastSerializer.cache = nil
     end
     expect(FastSerializer.cache).to eq nil
   end
-  
+
   it "should set the cache to Rails.cache with the value :rails" do
     begin
       rails = double(:cache => :rails_cache)
@@ -24,5 +25,16 @@ describe FastSerializer do
       FastSerializer.cache = nil
     end
   end
-  
+
+  it "should set the cache with an ActiveSupport cache" do
+    begin
+      cache_store = ActiveSupport::Cache::MemoryStore.new
+      FastSerializer.cache = cache_store
+      expect(FastSerializer.cache).to be_a FastSerializer::Cache::ActiveSupportCache
+      expect(FastSerializer.cache.cache).to eq cache_store
+    ensure
+      FastSerializer.cache = nil
+    end
+  end
+
 end

data/spec/serialization_context_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 describe FastSerializer::SerializationContext do
-  
+
   it "should get a single context only within a block" do
     expect(FastSerializer::SerializationContext.current).to eq nil
     FastSerializer::SerializationContext.use do
@@ -14,11 +14,11 @@ describe FastSerializer::SerializationContext do
     end
     expect(FastSerializer::SerializationContext.current).to eq nil
   end
-  
+
   it "should create serializers and reload them from cache with the same object and options" do
     context = FastSerializer::SerializationContext.new
     object = SimpleModel.new(:id => 1, :name => "foo")
-    
+
     serializer = context.load(SimpleSerializer, object, :count => 1)
     expect(serializer).to be_a SimpleSerializer
     expect(serializer.object).to eq object
@@ -28,5 +28,5 @@ describe FastSerializer::SerializationContext do
     expect(context.load(SimpleSerializer, SimpleModel.new(:id => 2, :name => "bar"), :count => 1).object_id).to_not eq serializer.object_id
     expect(context.load(SimpleSerializer, object, :count => 2).object_id).to_not eq serializer.object_id
   end
-  
+
 end

data/spec/serialized_field_spec.rb

@@ -1,66 +1,66 @@
 require 'spec_helper'
 
 describe FastSerializer::SerializedField do
-  
+
   let(:field){ FastSerializer::SerializedField.new(:test) }
   let(:model){ SimpleModel.new(:id => 1, :name => "foo") }
-  
+
   it "should integers" do
     expect(field.serialize(1)).to eq 1
   end
-  
+
   it "should serialize floats" do
     expect(field.serialize(1.5)).to eq 1.5
   end
-  
+
   it "should serialize strings" do
     expect(field.serialize("foo")).to eq "foo"
   end
-  
+
   it "should serialize symbols" do
     expect(field.serialize(:foo)).to eq :foo
   end
-  
+
   it "should serialize nil" do
     expect(field.serialize(nil)).to eq nil
   end
-  
+
   it "should serialize booleans" do
     expect(field.serialize(true)).to eq true
     expect(field.serialize(false)).to eq false
   end
-  
+
   it "should serialize times" do
     time = Time.now
     expect(field.serialize(time)).to eq time
   end
-  
+
   it "should serialize dates" do
     date = Date.today
     expect(field.serialize(date)).to eq date
   end
-  
+
   it "should serialize a field using a specified serializer" do
     field = FastSerializer::SerializedField.new(:test, serializer: SimpleSerializer)
     expect(field.serialize(model)).to eq({:id => 1, :name => "foo", :validated => false})
   end
-  
+
   it "should serialize an enumerable field using a specified serializer" do
     field = FastSerializer::SerializedField.new(:test, serializer: SimpleSerializer, enumerable: true)
     expect(field.serialize(model)).to eq([{:id => 1, :name => "foo", :validated => false}])
   end
-  
+
   it "should serialize a field value by calling as_json on the field" do
     expect(field.serialize(model)).to eq({:id => 1, :name => "foo", :description => nil, :number => nil})
   end
-  
+
   it "should serialize a hash of objects" do
     expect(field.serialize(:name => "Test", :object => model)).to eq({
       :name => "Test",
       :object => {:id => 1, :name => "foo", :description => nil, :number => nil}
     })
   end
-  
+
   it "should serialize an array of objects" do
     expect(field.serialize([model, model])).to eq([
       {:id => 1, :name => "foo", :description => nil, :number => nil},

data/spec/serializer_spec.rb

@@ -1,93 +1,93 @@
 require 'spec_helper'
 
 describe FastSerializer::Serializer do
-  
+
   let(:model){ SimpleModel.new(:id => 1, :name => "foo", :description => "foobar") }
-  
+
   it "should serialize object to JSON compatible format" do
     serializer = SimpleSerializer.new(model)
     expect(serializer.as_json).to eq({:id => 1, :name => "foo", :validated => false})
     expect(serializer.to_hash).to eq({:id => 1, :name => "foo", :validated => false})
     expect(serializer.to_h).to eq({:id => 1, :name => "foo", :validated => false})
   end
-  
+
   it "should serialize nil as nil" do
     expect(SimpleSerializer.new(nil).as_json).to eq nil
   end
-  
+
   it "should include optional fields only if included in the options" do
     expect(SimpleSerializer.new(model).as_json).to eq({:id => 1, :name => "foo", :validated => false})
     expect(SimpleSerializer.new(model, :include => :nothing).as_json).to eq({:id => 1, :name => "foo", :validated => false})
     expect(SimpleSerializer.new(model, :include => :description).as_json).to eq({:id => 1, :name => "foo", :validated => false, :description => "foobar"})
     expect(SimpleSerializer.new(model, :include => ["description"]).as_json).to eq({:id => 1, :name => "foo", :validated => false, :description => "foobar"})
   end
-  
+
   it "should exclude specified fields" do
     expect(SimpleSerializer.new(model, :exclude => :name).as_json).to eq({:id => 1, :validated => false})
     expect(SimpleSerializer.new(model, :exclude => ["id", "validated"]).as_json).to eq({:name => "foo"})
   end
-  
+
   it "should allow aliasing fields" do
     number_model = SimpleModel.new(:number => 50.5)
     expect(SimpleSerializer.new(number_model, :include => :amount).as_json).to eq({:id => nil, :name => nil, :validated => false, :amount => 50.5})
   end
-  
+
   it "should pull cached serializers from a cache" do
     serializer = SimpleSerializer.new(model)
     cached_serializer = CachedSerializer.new(model)
-    
+
     expect(serializer.cacheable?).to eq false
     expect(cached_serializer.cacheable?).to eq true
-    
+
     expect(serializer.cache_ttl).to eq nil
     expect(cached_serializer.cache_ttl).to eq 2
-    
+
     expect(cached_serializer.as_json).to eq serializer.as_json
     expect(cached_serializer.as_json.object_id).to eq cached_serializer.as_json.object_id
   end
-  
+
   it "should allow setting cache and ttl on parent serializers" do
     class SubCacheSerializer1 < CachedSerializer
       self.cache_ttl = 5
       self.cache = :mock
     end
-    
+
     class SubCacheSerializer2 < CachedSerializer
     end
-    
+
     expect(SubCacheSerializer1.cacheable?).to eq true
     expect(SubCacheSerializer2.cacheable?).to eq true
-    
+
     expect(SubCacheSerializer1.cache).to eq :mock
     expect(SubCacheSerializer2.cache).to eq CachedSerializer.cache
-    
+
     expect(SubCacheSerializer1.cache_ttl).to eq 5
     expect(SubCacheSerializer2.cache_ttl).to eq 2
   end
-  
+
   it "should allow setting cache and ttl on instances" do
     serializer = SimpleSerializer.new(model, :cacheable => true, :cache => :mock, :cache_ttl => 10)
     expect(serializer.cacheable?).to eq true
     expect(serializer.cache).to eq :mock
     expect(serializer.cache_ttl).to eq 10
   end
-  
+
   it "should get the cache from the global setting by default" do
     class SubCacheSerializerGlobalInheritTest
       include FastSerializer::Serializer
       self.cacheable
     end
-    
-    expect(SubCacheSerializerGlobalInheritTest.cache).to eq nil    
+
+    expect(SubCacheSerializerGlobalInheritTest.cache).to eq nil
     allow(FastSerializer).to receive_messages(:cache => :mock)
     expect(SubCacheSerializerGlobalInheritTest.cache).to eq :mock
   end
-  
+
   it "should not break on cached serializers if no cache is set" do
     serializer = CachedSerializer.new(model, :cache => nil)
     expect(serializer.as_json).to eq({:id => 1, :name => "foo", :validated => false})
   end
-  
+
   it "should serialize complex objects" do
     other_model = SimpleModel.new(:id => 3, :name => "other")
     complex = SimpleModel.new(:id => 2, :name => :complex, :parent => model, :associations => [model, other_model])
@@ -101,7 +101,7 @@ describe FastSerializer::Serializer do
       :parent => {:id => 1, :name => "foo", :validated => false}
     })
   end
-  
+
   it "should return identical serialized values for serializers on the same object and options inside the same context" do
     other_model = SimpleModel.new(:id => 3, :name => "other")
     complex = SimpleModel.new(:id => 2, :name => "complex", :associations => [model, other_model, model])
@@ -110,7 +110,7 @@ describe FastSerializer::Serializer do
     expect(json[:associations][0].object_id).to_not eq json[:associations][1].object_id
     expect(json[:associations][0].object_id).to eq json[:associations][2].object_id
   end
-  
+
   it "should dump the object to JSON" do
     complex = SimpleModel.new(:id => 2, :name => "complex", :parent => model, :associations => [model])
     serializer = ComplexSerializer.new(complex)
@@ -125,18 +125,24 @@ describe FastSerializer::Serializer do
       "parent" => {"id" => 1, "name" => "foo", "validated" => false}
     })
   end
-  
+
+  it "should allow passing options for JSON dumping" do
+    complex = SimpleModel.new(:id => 2, :name => "complex", :parent => model, :associations => [model])
+    serializer = ComplexSerializer.new(complex)
+    expect(serializer.to_json(:pretty => true)).to be_a(String)
+  end
+
   it "should expose options from the options hash by name" do
     serializer = CachedSerializer.new(model, :foo => "bar")
     expect(serializer.option(:foo)).to eq "bar"
     expect(serializer.option(:other)).to eq nil
   end
-  
+
   it "should return nil value for options if none are set" do
     serializer = CachedSerializer.new(model, nil)
     expect(serializer.option(:foo)).to eq nil
   end
-  
+
   it "should not get into infinite loops" do
     model = SimpleModel.new(:id => 1)
     model.parent = model

data/spec/spec_helper.rb

@@ -1,4 +1,6 @@
 require 'rspec'
+require 'active_support/cache'
+require 'active_support/cache/memory_store'
 require_relative "../lib/fast_serializer"
 require_relative "support/test_models"
 
@@ -11,6 +13,6 @@ RSpec.configure do |config|
   # the seed, which is printed after each run.
   #     --seed 1234
   config.order = 'random'
-  
+
   config.expect_with(:rspec) { |c| c.syntax = [:should, :expect] }
 end

data/spec/support/test_models.rb

@@ -1,7 +1,7 @@
 class SimpleModel
   attr_reader :id, :name, :description, :associations, :number
   attr_accessor :parent
-  
+
   def initialize(attributes = {})
     @id = attributes[:id]
     @name = attributes[:name]
@@ -11,11 +11,11 @@ class SimpleModel
     @parent = attributes[:parent]
     @number = attributes[:number]
   end
-  
+
   def validated?
     !!@validated
   end
-  
+
   def as_json(*args)
     {:id => @id, :name => @name, :description => @description, :number => @number}
   end
@@ -25,7 +25,7 @@ class TestCache < FastSerializer::Cache
   def initialize
     @cache = {}
   end
-  
+
   def fetch(serializer, ttl)
     val = @cache[serializer.cache_key]
     unless val
@@ -38,7 +38,7 @@ end
 
 class SimpleSerializer
   include FastSerializer::Serializer
-  
+
   serialize :id, :name, :validated?
   serialize :description, optional: true
   serialize :number, as: :amount, optional: true
@@ -52,7 +52,7 @@ class ComplexSerializer < SimpleSerializer
   serialize :serial_number, delegate: false
   serialize :associations, delegate: true, serializer: CachedSerializer, enumerable: true
   serialize :parent, delegate: true, serializer: SimpleSerializer
-  
+
   def serial_number
     option(:serial_number)
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fast_serializer
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
 platform: ruby
 authors:
 - We Heart It
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-23 00:00:00.000000000 Z
+date: 2018-08-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -53,6 +53,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: active_support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
 description: Super fast object serialization for API's combining a simple DSL with
   many optimizations under the hood.
 email:
@@ -63,7 +77,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
-- HISTORY.txt
+- HISTORY.md
 - MIT_LICENSE
 - README.md
 - Rakefile
@@ -77,6 +91,7 @@ files:
 - lib/fast_serializer/serialized_field.rb
 - lib/fast_serializer/serializer.rb
 - spec/array_serializer_spec.rb
+- spec/cache/active_support_cache_spec.rb
 - spec/fast_serializer_spec.rb
 - spec/serialization_context_spec.rb
 - spec/serialized_field_spec.rb
@@ -103,12 +118,13 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.12
+rubygems_version: 2.7.6
 signing_key: 
 specification_version: 4
 summary: Super fast object serialization for API's.
 test_files:
 - spec/array_serializer_spec.rb
+- spec/cache/active_support_cache_spec.rb
 - spec/fast_serializer_spec.rb
 - spec/serialization_context_spec.rb
 - spec/serialized_field_spec.rb

data/HISTORY.txt

@@ -1,7 +0,0 @@
-1.1.0
-
-Compatibility with change to fetch_multi in ActiveSupport 4.2.
-
-1.0.0
-
-* Initial release