fast_serializer 1.0.0

data/spec/fast_serializer_spec.rb

@@ -0,0 +1,28 @@
+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
+    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
+  
+end

data/spec/serialization_context_spec.rb

@@ -0,0 +1,32 @@
+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

data/spec/serialized_field_spec.rb

@@ -0,0 +1,71 @@
+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},
+      {:id => 1, :name => "foo", :description => nil, :number => nil}
+    ])
+  end
+
+end

data/spec/serializer_spec.rb

@@ -0,0 +1,146 @@
+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    
+    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])
+    serializer = ComplexSerializer.new(complex, :serial_number => 15)
+    expect(serializer.as_json).to eq({
+      :id => 2, :name => :complex, :validated => false, :serial_number => 15,
+      :associations => [
+        {:id => 1, :name => "foo", :validated => false},
+        {:id => 3, :name => "other", :validated => false}
+      ],
+      :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])
+    serializer = ComplexSerializer.new(complex)
+    json = serializer.as_json
+    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)
+    expect(JSON.load(serializer.to_json)).to eq({
+      "id" => 2,
+      "name" => "complex",
+      "validated" => false,
+      "serial_number" => nil,
+      "associations" => [
+        {"id" => 1, "name" => "foo", "validated" => false}
+      ],
+      "parent" => {"id" => 1, "name" => "foo", "validated" => false}
+    })
+  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
+    serializer = CircularSerializer.new(model)
+    expect{ serializer.as_json }.to raise_error(FastSerializer::CircularReferenceError)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,16 @@
+require 'rspec'
+require_relative "../lib/fast_serializer"
+require_relative "support/test_models"
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # 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

@@ -0,0 +1,64 @@
+class SimpleModel
+  attr_reader :id, :name, :description, :associations, :number
+  attr_accessor :parent
+  
+  def initialize(attributes = {})
+    @id = attributes[:id]
+    @name = attributes[:name]
+    @description = attributes[:description]
+    @validated = attributes[:validated]
+    @associations = attributes[:associations]
+    @parent = attributes[:parent]
+    @number = attributes[:number]
+  end
+  
+  def validated?
+    !!@validated
+  end
+  
+  def as_json(*args)
+    {:id => @id, :name => @name, :description => @description, :number => @number}
+  end
+end
+
+class TestCache < FastSerializer::Cache
+  def initialize
+    @cache = {}
+  end
+  
+  def fetch(serializer, ttl)
+    val = @cache[serializer.cache_key]
+    unless val
+      val = yield
+      @cache[serializer.cache_key] = val
+    end
+    val
+  end
+end
+
+class SimpleSerializer
+  include FastSerializer::Serializer
+  
+  serialize :id, :name, :validated?
+  serialize :description, optional: true
+  serialize :number, as: :amount, optional: true
+end
+
+class CachedSerializer < SimpleSerializer
+  cacheable ttl: 2, cache: TestCache.new
+end
+
+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
+end
+
+class CircularSerializer < SimpleSerializer
+  remove :name, :validated
+  serialize :parent, serializer: self
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: fast_serializer
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- We Heart It
+- Brian Durand
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-03-29 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
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !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'
+description: Super fast object serialization for API's combining a simple DSL with
+  many optimizations under the hood.
+email:
+- dev@weheartit.com
+- bbdurand@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- HISTORY.txt
+- MIT_LICENSE
+- README.md
+- Rakefile
+- VERSION
+- fast_serializer.gemspec
+- lib/fast_serializer.rb
+- lib/fast_serializer/array_serializer.rb
+- lib/fast_serializer/cache.rb
+- lib/fast_serializer/cache/active_support_cache.rb
+- lib/fast_serializer/serialization_context.rb
+- lib/fast_serializer/serialized_field.rb
+- lib/fast_serializer/serializer.rb
+- spec/array_serializer_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
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Super fast object serialization for API's.
+test_files:
+- spec/array_serializer_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