fast_serializer 1.1.1 → 1.1.3

data/lib/fast_serializer/serializer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module FastSerializer
   # Models can include this module to define themselves as serializers. A serializer is used to wrap
   # an object and output a hash version of that object suitable for serialization to JSON or other formats.
@@ -55,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)
@@ -100,19 +101,29 @@ 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)
-          options = fields.last
+          fields.last.each do |key, value|
+            options[key.to_sym] = value
+          end
           fields = fields[0, fields.size - 1]
         end
-        as = options[:as]
-        optional = options.fetch(:optional, false)
-        delegate = options.fetch(:delegate, true)
-        enumerable = options.fetch(:enumerable, false)
-        serializer = options[:serializer]
-        serializer_options = options[:serializer_options]
-        condition = options[:if]
+        as = options.delete(:as)
+        optional = options.delete(:optional) || false
+        delegate = options.delete(:delegate) || true
+        enumerable = options.delete(:enumerable) || false
+        serializer = options.delete(:serializer)
+        serializer_options = options.delete(:serializer_options)
+        condition = options.delete(:if)
+
+        unless options.empty?
+          raise ArgumentError.new("Unsupported serialize options: #{options.keys.join(", ")}")
+        end
 
         if as && fields.size > 1
           raise ArgumentError.new("Cannot specify :as argument with multiple fields to serialize")
@@ -120,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
@@ -136,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 = []
@@ -153,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
@@ -160,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?)
@@ -168,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
@@ -195,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)
@@ -214,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)
@@ -234,17 +263,17 @@ module FastSerializer
           private include_method_name
           condition = include_method_name
         end
-        
+
         field = SerializedField.new(name, optional: optional, serializer: serializer, serializer_options: serializer_options, enumerable: enumerable, condition: condition)
 
         # Add the field to the frozen list of fields.
         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
@@ -253,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
@@ -287,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 = {})
@@ -353,14 +380,14 @@ module FastSerializer
       SerializationContext.use do
         self.class.serializable_fields.each do |field|
           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
           next if condition && !send(condition)
-          
+
           value = field.serialize(send(name), serializer_options(name))
           hash[name] = value
         end
@@ -411,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,22 +1,22 @@
-require 'json'
-require 'time'
-require 'date'
+# frozen_string_literal: true
+
+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
@@ -24,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)

metadata

@@ -1,38 +1,23 @@
 --- !ruby/object:Gem::Specification
 name: fast_serializer
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.1.3
 platform: ruby
 authors:
-- We Heart It
 - Brian Durand
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-01-12 00:00:00.000000000 Z
+date: 2023-11-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: bundler
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '1.3'
-- !ruby/object:Gem::Dependency
-  name: rake
+  name: redis
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-  type: :development
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
@@ -40,47 +25,29 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rspec
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: active_support
+  name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '4.0'
+        version: '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.
+        version: '0'
+description:
 email:
-- dev@weheartit.com
 - bbdurand@gmail.com
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".gitignore"
-- HISTORY.md
+- CHANGELOG.md
 - MIT_LICENSE
 - README.md
-- Rakefile
 - VERSION
 - fast_serializer.gemspec
 - lib/fast_serializer.rb
@@ -90,19 +57,11 @@ files:
 - lib/fast_serializer/serialization_context.rb
 - 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
-- spec/serializer_spec.rb
-- spec/spec_helper.rb
-- spec/support/test_models.rb
-homepage: https://github.com/weheartit/fast_serializer
+homepage: https://github.com/bdurand/fast_serializer
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -110,24 +69,16 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '2.5'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.6
-signing_key: 
+rubygems_version: 3.4.12
+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
-- spec/serializer_spec.rb
-- spec/spec_helper.rb
-- spec/support/test_models.rb
+summary: Super fast object serialization for API's combining a simple DSL with many
+  optimizations under the hood.
+test_files: []

data/.gitignore

@@ -1,17 +0,0 @@
-*.gem
-*.rbc
-.bundle
-.config
-.yardoc
-Gemfile.lock
-InstalledFiles
-_yardoc
-coverage
-doc/
-lib/bundler/man
-pkg
-rdoc
-spec/reports
-test/tmp
-test/version_tmp
-tmp

data/HISTORY.md

@@ -1,25 +0,0 @@
-### 1.1.1
-
-* Add `array` class method to serializers.
-
-### 1.1.0
-
-* 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
-
-* Better integration with ActiveSupport caching.
-
-### 1.0.1
-
-* Compatibility with change to fetch_multi in ActiveSupport 4.2.
-
-### 1.0.0
-
-* Initial release

data/Rakefile

@@ -1,18 +0,0 @@
-require "bundler/gem_tasks"
-
-desc 'Default: run unit tests.'
-task :default => :test
-
-desc 'RVM likes to call it tests'
-task :tests => :test
-
-begin
-  require 'rspec'
-  require 'rspec/core/rake_task'
-  desc 'Run the unit tests'
-  RSpec::Core::RakeTask.new(:test)
-rescue LoadError
-  task :test do
-    STDERR.puts "You must have rspec >= 2.0 installed to run the tests"
-  end
-end

data/spec/array_serializer_spec.rb

@@ -1,67 +0,0 @@
-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")
-    serializer = FastSerializer::ArraySerializer.new([model_1, model_2], :serializer => SimpleSerializer)
-    expect(JSON.load(serializer.to_json)).to eq [
-      {"id" => 1, "name" => "foo", "validated" => false},
-      {"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")
-    serializer = FastSerializer::ArraySerializer.new([model_1, model_2], :serializer => SimpleSerializer, :serializer_options => {:include => :description})
-    expect(JSON.load(serializer.to_json)).to eq [
-      {"id" => 1, "name" => "foo", "validated" => false, "description" => nil},
-      {"id" => 2, "name" => "bar", "validated" => false, "description" => nil}
-    ]
-  end
-
-  it "should be able to use the array helper method on a serializer to serialize an array of objects" do
-    model_1 = SimpleModel.new(:id => 1, :name => "foo")
-    model_2 = SimpleModel.new(:id => 2, :name => "bar")
-    array_serializer = FastSerializer::ArraySerializer.new([model_1, model_2], :serializer => SimpleSerializer, :serializer_options => {:include => :description})
-    helper_serializer = SimpleSerializer.array([model_1, model_2], :serializer_options => {:include => :description})
-    expect(array_serializer.to_json).to eq helper_serializer.to_json
-  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")
-    serializer = FastSerializer::ArraySerializer.new([model_1, model_2], serializer: CachedSerializer)
-    expect(serializer.cacheable?).to eq true
-    already_cached_json = CachedSerializer.new(model_1).as_json
-    expect(serializer.as_json.collect(&:object_id)).to eq [already_cached_json.object_id, CachedSerializer.new(model_2).as_json.object_id]
-  end
-
-end

data/spec/cache/active_support_cache_spec.rb

@@ -1,24 +0,0 @@
-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,40 +0,0 @@
-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
-      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)
-      stub_const("Rails", rails)
-      FastSerializer.cache = :rails
-      expect(FastSerializer.cache).to be_a FastSerializer::Cache::ActiveSupportCache
-      expect(FastSerializer.cache.cache).to eq :rails_cache
-    ensure
-      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,32 +0,0 @@
-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
-      context = FastSerializer::SerializationContext.current
-      expect(FastSerializer::SerializationContext.current).to_not eq nil
-      FastSerializer::SerializationContext.use do
-        expect(FastSerializer::SerializationContext.current).to eq context
-      end
-      expect(FastSerializer::SerializationContext.current).to eq context
-    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
-    expect(serializer.options).to eq(:count => 1)
-
-    expect(context.load(SimpleSerializer, object, :count => 1).object_id).to eq serializer.object_id
-    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