ruby-serializer 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 76d0570d6c6888182f54fad8d93447115da9b15d
+  data.tar.gz: fadc5ff494af8792ba60f1c76b90cc822ed90f4c
+SHA512:
+  metadata.gz: 0d35417352d902d4e46cd7de29e7151fe6024b784f6b46a0029bf38cd4db8545c8e559f6f71a82e9d75dbcefadf3411eab517a7b60ab4dc39baa23aeaae2313a
+  data.tar.gz: 5a0ea330adc5f8ad4cdac778524677342547f30888fadadae3f527b2a685070e6f32557a8854d6a759647747638a6f60593a9224967241cda736521663ed6c35

data/.gitignore

@@ -0,0 +1,13 @@
+/ruby-serializer*.gem
+
+/.bundle
+/log/*
+/tmp/*
+
+*.swp
+*.env
+
+.DS_Store
+._.DS_Store
+
+.byebug_history

data/Gemfile

@@ -0,0 +1,3 @@
+source 'http://rubygems.org'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,25 @@
+PATH
+  remote: .
+  specs:
+    ruby-serializer (0.0.1)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    awesome_print (1.7.0)
+    byebug (9.0.5)
+    minitest (5.9.0)
+    rake (11.2.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  awesome_print (~> 1.7)
+  byebug (~> 9.0)
+  minitest (~> 5.9)
+  rake (~> 11.0)
+  ruby-serializer!
+
+BUNDLED WITH
+   1.12.3

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2016, Jake Gordon and contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

data/Rakefile

@@ -0,0 +1,10 @@
+require 'rake/testtask'
+
+#------------------------------------------------------------------------------
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*_test.rb']
+  t.verbose = true
+end
+
+#------------------------------------------------------------------------------

data/lib/ruby_serializer/base.rb

@@ -0,0 +1,62 @@
+module RubySerializer
+  class Base
+
+    extend RubySerializer::Dsl
+
+    attr_reader :options, :include # only populated during #serialize and (temporarily) stores the #serialize options to make
+                                   # them available to any potential :value, :only and :unless lambdas in the derived serializer
+
+    def initialize(resource)
+      @resource = resource
+    end
+
+    def as_json(options = {})
+      json = serialize(options)
+      json = { options[:root] => json } if options[:root]
+      json
+    end
+
+    #----------------------------------------------------------------------------------------------
+    # PRIVATE implementation
+    #----------------------------------------------------------------------------------------------
+
+    private
+
+    attr_reader :resource
+
+    def serialize(options = {})
+      if resource.respond_to? :to_ary
+        serialize_array(options)
+      else
+        serialize_object(options)
+      end
+    end
+
+    def serialize_array(options)
+      resource.map do |item|
+        serializer = RubySerializer.build(item)
+        serializer.send :serialize, options.merge(root: nil)
+      end
+    end
+
+    def serialize_object(options)
+      @options = options
+      json = {}
+      json[:errors] = resource.errors if resource.respond_to?(:valid?) && !resource.valid?
+      self.class.fields.each do |field|
+        next unless field.present?(resource, self)
+        key = field.as
+        ns  = namespace(field, json)
+        ns[key] = field.serialize(resource, self)
+      end
+      json
+    end
+
+    def namespace(field, json)
+      field.namespace.reduce(json) { |ns, name| ns[name] ||= {} }
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+  end
+end

data/lib/ruby_serializer/dsl.rb

@@ -0,0 +1,27 @@
+module RubySerializer
+  module Dsl
+
+    def serializes(name)
+      define_method(name) do   # provide a friendly-name accessor to the underlying resource
+        resource
+      end
+    end
+
+    def expose(field, options = {})
+      fields << Field.new(field, namespace, options)
+    end
+
+    def fields
+      @fields ||= []
+    end
+
+    def namespace(ns = nil, &block)
+      @namespace ||= []
+      return @namespace if ns.nil?  # this method acts as both getter (this line) and setter (subsequent)
+      @namespace.push(ns)
+      block.call(binding)
+      @namespace.pop
+    end
+
+  end
+end

data/lib/ruby_serializer/field.rb

@@ -0,0 +1,55 @@
+module RubySerializer
+  class Field
+
+    attr_reader :field, :as, :from, :value, :namespace
+
+    def initialize(field, namespace, options)
+      @field     = field.to_sym
+      @as        = options[:as]   || field
+      @from      = options[:from] || field
+      @value     = options[:value]
+      @only      = options[:only]
+      @unless    = options[:unless]
+      @namespace = namespace.dup
+    end
+
+    def serialize(resource, serializer)
+      case value
+      when nil    then resource.send(from)
+      when Symbol then resource.send(value)
+      when Proc   then serializer.instance_exec(&value)
+      else
+        value
+      end
+    end
+
+    def present?(resource, serializer)
+      only?(resource, serializer) && !unless?(resource, serializer)
+    end
+
+    def only?(resource, serializer)
+      case @only
+      when nil    then true
+      when true   then true
+      when false  then false
+      when Symbol then resource.send(@only)
+      when Proc   then serializer.instance_exec(&@only)
+      else
+        raise ArgumentError, "unexpected #{@only}"
+      end
+    end
+
+    def unless?(resource, serializer)
+      case @unless
+      when nil    then false
+      when true   then true
+      when false  then false
+      when Symbol then resource.send(@unless)
+      when Proc   then serializer.instance_exec(&@unless)
+      else
+        raise ArgumentError, "unexpected #{@unless}"
+      end
+    end
+
+  end
+end

data/lib/ruby_serializer.rb

@@ -0,0 +1,46 @@
+module RubySerializer
+
+  #------------------------------------------------------------------------------------------------
+
+  VERSION     = '0.0.1'
+  SUMMARY     = 'Serialize POROs to JSON'
+  DESCRIPTION = 'A general purpose library for serializing plain old ruby objects (POROs) into JSON using a declarative DSL'
+  LIB         = File.dirname(__FILE__)
+
+  #------------------------------------------------------------------------------------------------
+
+  autoload :Dsl,   File.join(LIB, 'ruby_serializer/dsl')
+  autoload :Base,  File.join(LIB, 'ruby_serializer/base')
+  autoload :Field, File.join(LIB, 'ruby_serializer/field')
+
+  #------------------------------------------------------------------------------------------------
+
+  def self.build(resource, options = {})
+    serializer_class = options[:with] || options[:serializer] || detect_serializer(resource)
+    serializer_class.new(resource)
+  end
+
+  #------------------------------------------------------------------------------------------------
+
+  def self.as_json(resource, options = {})
+    build_options = {
+      with:       options.delete(:with),
+      serializer: options.delete(:serializer)
+    }
+    build(resource, build_options).as_json(options)
+  end
+
+  #------------------------------------------------------------------------------------------------
+
+  def self.detect_serializer(resource)
+    return RubySerializer::Base if resource.respond_to?(:to_ary)
+    namespace = resource.class.name.split("::")
+    scope   = Kernel.const_get namespace[0...-1].join("::") if namespace.length > 1
+    scope ||= Kernel
+    name = namespace.last
+    scope.const_get "#{name}Serializer"
+  end
+
+  #------------------------------------------------------------------------------------------------
+
+end

data/readme.md

@@ -0,0 +1,110 @@
+# Ruby Serializer (v0.0.1)
+
+A general purpose library for serializing models (e.g, an ActiveModel or a PORO)
+into JSON using a declarative DSL. 
+
+## Installation
+
+```bash
+    $ gem install ruby-serializer      # ... or add to your Gemfile as appropriate
+```
+
+## Usage
+
+Assuming you have a model similar to...
+
+```ruby
+  class Shape
+    attr :size, :color, :shape, ...
+  end
+```
+
+You can declare a serializer as follows...
+
+```ruby
+  class ShapeSerializer < RubySerializer::Base
+    expose :size
+    expose :color
+    expose :shape
+  end
+```
+
+And serialize using...
+
+```ruby
+  shape = Shape.new(size: 'large', color: 'red', shape: 'square')    # load as appropriate
+  json  = RubySerializer.as_json shape
+  
+  # { size: 'large', color: 'red', shape: 'square' }
+```
+
+## Beyond the basics
+
+Ok, that was very basic, but with RubySerializer you can also:
+
+  * expose attributes `:as` another name
+  * expose attributes with a custom `:value`
+  * expose attributes conditionally with `:only` and `:unless`
+  * expose attributes within a nested `:namespace`
+  * expose model `:errors` if `!model.valid?`
+  * `:include` nested `:belongs_to` associated models
+  * `:include` nested `:has_one` associated models
+  * `:include` nested `:has_many` associated models
+  * serialize an array of models
+  * add `ActionController` integration for easy API serialization
+
+### Exposing attributes with another name
+
+>> _TODO_
+
+### Exposing attributes with custom values
+
+>> _TODO_
+
+### Exposing attributes conditionally
+
+>> _TODO_
+
+### Exposing attributes within a namespace
+
+>> _TODO_
+
+### Exposing model validation errors
+
+>> _TODO_
+
+### Exposing associations
+
+>> _TODO_
+
+### Serializing arrays
+
+>> _TODO_
+
+### ActionController integration
+
+>> _TODO_
+
+# TODO
+
+  * :belongs_to
+  * :has_one
+  * :has_many
+  * :includes
+  * ActionController integration
+  * documentation
+
+# Roadmap
+
+  * Extensibility with custom Field types
+ 
+# License
+
+See [LICENSE](https://github.com/jakesgordon/ruby-serializer/blob/master/LICENSE) file.
+
+# Contact
+
+If you have any ideas, feedback, requests or bug reports, you can reach me at
+[jake@codeincomplete.com](mailto:jake@codeincomplete.com), or via
+my website: [Code inComplete](http://codeincomplete.com).
+

data/ruby-serializer.gemspec

@@ -0,0 +1,31 @@
+# -*- encoding: utf-8 -*-
+require_relative 'lib/ruby_serializer'
+
+Gem::Specification.new do |s|
+
+  s.name        = "ruby-serializer"
+  s.version     = RubySerializer::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Jake Gordon"]
+  s.email       = ["jake@codeincomplete.com"]
+  s.homepage    = "https://github.com/jakesgordon/ruby-serializer"
+  s.summary     = RubySerializer::SUMMARY
+  s.description = RubySerializer::DESCRIPTION
+  s.licenses    = [ 'MIT' ]
+
+  s.required_ruby_version = '~> 2.3'
+
+  s.add_development_dependency 'rake',          '~> 11.0'
+  s.add_development_dependency 'minitest',      '~> 5.9'
+  s.add_development_dependency 'awesome_print', '~> 1.7'
+  s.add_development_dependency 'byebug',        '~> 9.0'
+
+  s.has_rdoc         = false
+  s.extra_rdoc_files = ["readme.md"]
+  s.rdoc_options     = ["--charset=UTF-8"]
+  s.files            = `git ls-files `.split("\n")
+  s.test_files       = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables      = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths    = ["lib"]
+
+end

data/test/basic_test.rb

@@ -0,0 +1,95 @@
+require_relative 'test_case'
+
+module RubySerializer
+  class BasicTest < TestCase
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_gem_information
+      assert_equal '0.0.1',                         VERSION
+      assert_equal 'Serialize POROs to JSON',       SUMMARY
+      assert_match 'A general purpose library for', DESCRIPTION
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    Shape = Struct.new(:color, :shape)
+    Car   = Struct.new(:make, :model)
+
+    class ShapeSerializer < RubySerializer::Base
+      expose :color
+      expose :shape
+    end
+
+    class CarSerializer < RubySerializer::Base
+      expose :make
+      expose :model
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_basic_serialization
+
+      json = RubySerializer.as_json Shape.new(:red, :square)
+      assert_set   [ :color, :shape ], json.keys
+      assert_equal :red,               json[:color]
+      assert_equal :square,            json[:shape]
+
+      json = RubySerializer.as_json Car.new(:honda, :civic)
+      assert_set   [ :make, :model ], json.keys
+      assert_equal :honda,            json[:make]
+      assert_equal :civic,            json[:model]
+
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_array_serialization
+      resources = [
+        Shape.new(:red,  :square),
+        Shape.new(:blue, :circle),
+        Car.new(:honda, :civic),
+        Car.new(:jeep, :wrangler)
+      ]
+      json = RubySerializer.as_json resources
+      assert_equal resources.length, json.length
+      assert_set   [ :color, :shape ], json[0].keys
+      assert_equal :red,               json[0][:color]
+      assert_equal :square,            json[0][:shape]
+      assert_equal [ :color, :shape ], json[1].keys
+      assert_equal :blue,              json[1][:color]
+      assert_equal :circle,            json[1][:shape]
+      assert_equal [ :make, :model ],  json[2].keys
+      assert_equal :honda,             json[2][:make]
+      assert_equal :civic,             json[2][:model]
+      assert_equal [ :make, :model ],  json[3].keys
+      assert_equal :jeep,              json[3][:make]
+      assert_equal :wrangler,          json[3][:model]
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_serialize_with_root
+      json = RubySerializer.as_json Car.new(:honda, :civic), root: :car
+      assert_set [ :car ], json.keys
+      assert_equal :honda, json[:car][:make]
+      assert_equal :civic, json[:car][:model]
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_serialize_with_errors
+      resource = OpenStruct.new(color: :red, shape: :sausages, valid?: false, errors: { shape: 'is invalid' })
+      json     = RubySerializer.as_json resource, with: ShapeSerializer
+      expected = [ :color, :shape, :errors ]
+      assert_set expected,       json.keys
+      assert_equal :red,         json[:color]
+      assert_equal :sausages,    json[:shape]
+      assert_set   [ :shape ],   json[:errors].keys
+      assert_equal 'is invalid', json[:errors][:shape]
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+  end
+end

data/test/expose_test.rb

@@ -0,0 +1,197 @@
+require_relative 'test_case'
+
+module RubySerializer
+  class ExposeTest < TestCase
+
+    #----------------------------------------------------------------------------------------------
+
+    ID     = 42
+    NAME   = 'Name'
+    EMAIL  = 'Email'
+    SECRET = 'Secret'
+
+    Resource = OpenStruct
+
+    #==============================================================================================
+    # Sample Serializers
+    #==============================================================================================
+
+    class BasicSerializer < RubySerializer::Base
+      expose :id
+      expose :name
+      expose :email
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    class RenamingSerializer < RubySerializer::Base
+      expose :id
+      expose :name,       as:   :user_name
+      expose :user_email, from: :email
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    class NamespaceSerializer < RubySerializer::Base
+      expose :id
+      namespace :user do
+        expose :name
+        expose :email
+      end
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    class CustomValueSerializer < RubySerializer::Base
+      expose :id
+      expose :static,  value: 'static value'
+      expose :method,  value: :method_value
+      expose :dynamic, value: -> { "dynamic value (#{resource.name})" }
+      expose :empty,   value: nil
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    class ConditionalSerializer < RubySerializer::Base
+      expose :id
+      expose :only_true,      value: 'only true',      only: true
+      expose :only_false,     value: 'only false',     only: false
+      expose :only_method,    value: 'only method',    only: :show
+      expose :only_dynamic,   value: 'only dynamic',   only: -> { resource.show }
+      expose :unless_true,    value: 'unless true',    unless: true
+      expose :unless_false,   value: 'unless false',   unless: false
+      expose :unless_method,  value: 'unless method',  unless: :show
+      expose :unless_dynamic, value: 'unless dynamic', unless: -> { resource.show }
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    class CustomResourceNameSerializer < RubySerializer::Base
+      serializes :user
+      expose :id
+      expose :value,       value: -> { "value is #{user.value}" }
+      expose :show_only,   value: 'show only',   only: ->   { user.show }
+      expose :show_unless, value: 'show unless', unless: -> { user.show }
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    class CustomOptionsSerializer < RubySerializer::Base
+      expose :id
+      expose :value,       value: -> { "value is #{options[:value]}" }
+      expose :show_only,   value: 'show only',   only: ->   { options[:show] }
+      expose :show_unless, value: 'show unless', unless: -> { options[:show] }
+    end
+
+    #==============================================================================================
+    # TESTS
+    #==============================================================================================
+
+    def test_expose_attributes_unchanged
+      resource = Resource.new(id: ID, name: NAME, email: EMAIL, secret: SECRET)
+      json     = RubySerializer.as_json resource, with: BasicSerializer
+      expected = [ :id, :name, :email ]
+      assert_set   expected, json.keys
+      assert_equal ID,       json[:id]
+      assert_equal NAME,     json[:name]
+      assert_equal EMAIL,    json[:email]
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_expose_renamed_attributes
+      resource = Resource.new(id: ID, name: NAME, email: EMAIL, secret: SECRET)
+      json     = RubySerializer.as_json resource, with: RenamingSerializer
+      expected = [ :id, :user_name, :user_email ]
+      assert_set   expected, json.keys
+      assert_equal ID,       json[:id]
+      assert_equal NAME,     json[:user_name]
+      assert_equal EMAIL,    json[:user_email]
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_expose_namespaced_attributes
+      resource = Resource.new(id: ID, name: NAME, email: EMAIL, secret: SECRET)
+      json     = RubySerializer.as_json resource, with: NamespaceSerializer
+      expected = [ :id, :user ]
+      assert_set   expected,          json.keys
+      assert_equal ID,                json[:id]
+      assert_equal NAME,              json[:user][:name]
+      assert_equal EMAIL,             json[:user][:email]
+      assert_equal [ :name, :email ], json[:user].keys
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_expose_attributes_with_custom_values
+      resource = Resource.new(id: ID, name: NAME, method_value: 'method value')
+      json     = RubySerializer.as_json resource, with: CustomValueSerializer
+      expected = [ :id, :static, :dynamic, :method, :empty ]
+      assert_set   expected,               json.keys
+      assert_equal ID,                     json[:id]
+      assert_equal 'static value',         json[:static]
+      assert_equal 'dynamic value (Name)', json[:dynamic]
+      assert_equal 'method value',         json[:method]
+      assert_equal nil,                    json[:empty]
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_expose_attributes_conditionally
+      show        = RubySerializer.as_json Resource.new(id: ID, show: true),  with: ConditionalSerializer
+      noshow      = RubySerializer.as_json Resource.new(id: ID, show: false), with: ConditionalSerializer
+      unspecified = RubySerializer.as_json Resource.new(id: ID),              with: ConditionalSerializer
+      assert_set [ :id, :only_true, :unless_false, :only_method,   :only_dynamic   ], show.keys
+      assert_set [ :id, :only_true, :unless_false, :unless_method, :unless_dynamic ], noshow.keys
+      assert_set [ :id, :only_true, :unless_false, :unless_method, :unless_dynamic ], unspecified.keys
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_expose_attributes_using_custom_resource_name
+
+      resource = Resource.new(id: ID, value: 42, show: false)
+      json     = RubySerializer.as_json resource, with: CustomResourceNameSerializer
+      expected = [ :id, :value, :show_unless ]
+      assert_set   expected,      json.keys
+      assert_equal ID,            json[:id]
+      assert_equal "value is 42", json[:value]
+      assert_equal "show unless", json[:show_unless]
+
+      resource = Resource.new(id: ID, value: 99, show: true)
+      json     = RubySerializer.as_json resource, with: CustomResourceNameSerializer
+      expected = [ :id, :value, :show_only ]
+      assert_set   expected,      json.keys
+      assert_equal ID,            json[:id]
+      assert_equal "value is 99", json[:value]
+      assert_equal "show only",   json[:show_only]
+
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+    def test_expose_attributes_using_arbitrary_options_passed_into_serializer
+
+      resource = Resource.new(id: ID)
+
+      json     = RubySerializer.as_json resource, value: 42, show: false, with: CustomOptionsSerializer
+      expected = [ :id, :value, :show_unless ]
+      assert_set   expected,      json.keys
+      assert_equal ID,            json[:id]
+      assert_equal "value is 42", json[:value]
+      assert_equal "show unless", json[:show_unless]
+
+      json     = RubySerializer.as_json resource, value: 99, show: true, with: CustomOptionsSerializer
+      expected = [ :id, :value, :show_only ]
+      assert_set   expected,      json.keys
+      assert_equal ID,            json[:id]
+      assert_equal "value is 99", json[:value]
+      assert_equal "show only",   json[:show_only]
+
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+  end
+end

data/test/test_case.rb

@@ -0,0 +1,19 @@
+require_relative '../lib/ruby_serializer'
+
+require 'minitest/autorun'
+require 'minitest/pride'
+require 'byebug'
+
+module RubySerializer
+  class TestCase < Minitest::Test
+
+    #----------------------------------------------------------------------------------------------
+
+    def assert_set(expected, actual, message = nil)
+      assert_equal Set.new(expected), Set.new(actual), message
+    end
+
+    #----------------------------------------------------------------------------------------------
+
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification
+name: ruby-serializer
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jake Gordon
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-07-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '11.0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.9'
+- !ruby/object:Gem::Dependency
+  name: awesome_print
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '9.0'
+description: A general purpose library for serializing plain old ruby objects (POROs)
+  into JSON using a declarative DSL
+email:
+- jake@codeincomplete.com
+executables: []
+extensions: []
+extra_rdoc_files:
+- readme.md
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- Rakefile
+- lib/ruby_serializer.rb
+- lib/ruby_serializer/base.rb
+- lib/ruby_serializer/dsl.rb
+- lib/ruby_serializer/field.rb
+- readme.md
+- ruby-serializer.gemspec
+- test/basic_test.rb
+- test/expose_test.rb
+- test/test_case.rb
+homepage: https://github.com/jakesgordon/ruby-serializer
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.3'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Serialize POROs to JSON
+test_files: []