postgres_ext-serializers 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bc2786f412177b97b379240e2c651b3af66b4529
+  data.tar.gz: a593579437d26066cdc7ba5afce361447cd27bb5
+SHA512:
+  metadata.gz: dedcaefb8fa0a5228cd7221381550621eed39c63c7c031e88483e901ccf57aa587c4a79ffc4cc0f8a0420a15b7c42ebb8fe3c31cf1623a9bb2a8a94c3a81c4ac
+  data.tar.gz: c7ef64efe1d96a3aa2171560b6d775b7706fc736c0d1840bd5ba1d1e56330bb973b996cc2d43e17082e1d4196ab9ff4b0fbbdac99f9174394a307a684c220040

data/.gitignore

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

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in postgres_ext-serializers.gemspec
+gemspec
+
+unless ENV['CI'] || RUBY_PLATFORM =~ /java/
+  gem 'byebug'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Dan McClain
+
+MIT License
+
+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/README.md

@@ -0,0 +1,82 @@
+# PostgresExt-Serializers
+
+
+[![Build
+Status](https://secure.travis-ci.org/dockyard/postgres_ext-serializers.png?branch=master)](http://travis-ci.org/dockyard/postgres_ext-serializers)
+[![Code
+Climate](https://codeclimate.com/github/dockyard/postgres_ext-serializers.png)](https://codeclimate.com/github/dockyard/postgres_ext-serializers)
+[![Gem
+Version](https://badge.fury.io/rb/postgres_ext-serializers.png)](http://badge.fury.io/rb/postgres_ext-serializers)
+
+## Looking for help? ##
+
+If it is a bug [please open an issue on
+Github](https://github.com/dockyard/postgres_ext-serializers/issues). If you need
+help using the gem please ask the question on
+[Stack Overflow](http://stackoverflow.com). Be sure to tag the
+question with `DockYard` so we can find it.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'postgres_ext-serializers'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install postgres_ext-serializers
+
+## Usage
+
+Just `require 'postgres_ext/serializers'` and use
+ActiveModel::Serializers as you normally would!
+Postgres\_ext-serializers will take over anytime you try to serialize an
+ActiveRecord::Relation.
+
+### Methods in Serializers and Models
+
+If you are using methods to compute properties for your JSON responses
+in your models or serializers, postgres\_ext-serializers will try to
+discover a SQL version of this call by looking for a class method with
+the same name and the prefex `__sql`. Here's an example:
+
+```ruby
+class MySerializer < ActiveModel::Serializer
+  def full_name
+    "#{object.first_name} #{object.last_name}"
+  end
+
+  def self.full_name__sql(scope)
+    'first_name || ' ' || last_name'
+  end
+end
+```
+
+The scope is passed to methods in a serializer, while there are no
+arguments passed to `__sql` methods in a model. You will not have access
+to the `current_user` alias of `scope`, but the scope passed in will be
+the same object. Right now, this string is used as a SQL literal, so be
+sure to *not* use untrusted values in the return value. This feature may
+change before the 1.0 release, if a cleaner implementation is found.
+
+## Developing
+
+To work on postgres\_ext locally, follow these steps:
+
+ 1. Run `bundle install`, this will install all the development
+    dependencies
+ 2. Run `rake setup`, this will set up the `.env` file necessary to run
+    the tests and set up the database
+ 3. Run `rake db:create`, this will create the test database
+ 4. Run `rake db:migrate`, this will set up the database tables required
+    by the test
+
+## Authors
+
+Dan McClain [twitter](http://twitter.com/_danmcclain)
+[github](http://github.com/danmcclain)
+

data/Rakefile

@@ -0,0 +1,88 @@
+require 'bundler/gem_tasks'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task :default => :test
+
+task :setup do
+  if File.exist?('.env')
+    puts 'This will overwrite your existing .env file'
+  end
+  print 'Enter your database name: [postgres_ext_serializers_test] '
+  db_name = STDIN.gets.chomp
+  print 'Enter your database user: [] '
+  db_user = STDIN.gets.chomp
+  print 'Enter your database password: [] '
+  db_password = STDIN.gets.chomp
+  print 'Enter your database server: [localhost] '
+  db_server = STDIN.gets.chomp
+
+  db_name = 'postgres_ext_test' if db_name.empty?
+  db_password = ":#{db_password}" unless db_password.empty?
+  db_server = 'localhost' if db_server.empty?
+
+  db_server = "@#{db_server}" unless db_user.empty?
+
+  env_path = File.expand_path('./.env')
+  File.open(env_path, 'w') do |file|
+    file.puts "DATABASE_NAME=#{db_name}"
+    file.puts "DATABASE_URL=\"postgres://#{db_user}#{db_password}#{db_server}/#{db_name}\""
+  end
+
+  puts '.env file saved'
+end
+
+namespace :db do
+  task :load_db_settings do
+    require 'active_record'
+    unless ENV['DATABASE_URL']
+      require 'dotenv'
+      Dotenv.load
+    end
+  end
+
+  task :psql => :load_db_settings do
+    exec "psql #{ENV['DATABASE_NAME']}"
+  end
+
+  task :drop => :load_db_settings do
+    %x{ dropdb #{ENV['DATABASE_NAME']} }
+  end
+
+  task :create => :load_db_settings do
+    %x{ createdb #{ENV['DATABASE_NAME']} }
+  end
+
+  task :migrate => :load_db_settings do
+    ActiveRecord::Base.establish_connection
+
+    ActiveRecord::Base.connection.create_table :people, force: true do |t|
+      t.string   "first_name"
+      t.string   "last_name"
+      t.datetime "created_at"
+      t.datetime "updated_at"
+    end
+
+    ActiveRecord::Base.connection.create_table :notes, force: true do |t|
+      t.string   "name"
+      t.string   "content"
+      t.datetime "created_at"
+      t.datetime "updated_at"
+    end
+
+    ActiveRecord::Base.connection.create_table :tags, force: true do |t|
+      t.integer  "note_id"
+      t.string   "name"
+      t.datetime "created_at"
+      t.datetime "updated_at"
+    end
+
+    puts 'Database migrated'
+  end
+end

data/lib/postgres_ext/serializers.rb

@@ -0,0 +1,12 @@
+require 'postgres_ext'
+require 'postgres_ext/serializers/version'
+
+module PostgresExt
+  module Serializers
+  end
+end
+
+require 'postgres_ext/serializers/active_model'
+require 'active_model_serializers'
+
+ActiveModel::ArraySerializer.send :prepend, PostgresExt::Serializers::ActiveModel::ArraySerializer

data/lib/postgres_ext/serializers/active_model.rb

@@ -0,0 +1,6 @@
+module PostgresExt::Serializers
+  module ActiveModel
+  end
+end
+
+require 'postgres_ext/serializers/active_model/array_serializer'

data/lib/postgres_ext/serializers/active_model/array_serializer.rb

@@ -0,0 +1,194 @@
+module PostgresExt::Serializers::ActiveModel
+  module ArraySerializer
+    def self.prepended(base)
+      base.send :include, IncludeMethods
+    end
+
+    module IncludeMethods
+      def to_json(*)
+        if ActiveRecord::Relation === object
+          _postgres_serializable_array
+        else
+          super
+        end
+      end
+    end
+
+    def initialize(*)
+      super
+      @_ctes = []
+      @_results_tables = []
+      @_embedded = []
+    end
+
+    private
+
+    def _postgres_serializable_array
+      _include_relation_in_root(object)
+
+      jsons_select_manager = _results_table_arel
+      jsons_select_manager.with @_ctes
+
+      object.klass.connection.select_value _visitor.accept(jsons_select_manager)
+    end
+
+    def _include_relation_in_root(relation, foreign_key_column = nil, constraining_table = nil)
+      relation_query = relation.dup
+      relation_query_arel = relation_query.arel_table
+      @_embedded << relation.table_name
+
+      klass = ActiveRecord::Relation === relation ? relation.klass : relation
+      serializer_class = _serializer_class(klass)
+      _serializer = serializer_class.new klass.new, options
+
+      attributes = serializer_class._attributes
+      attributes.each do |name, key|
+        if name.to_s == key.to_s
+          if serializer_class.respond_to? "#{name}__sql"
+            relation_query = relation_query.select Arel::Nodes::As.new Arel.sql(serializer_class.send("#{name}__sql", options[:scope])), Arel.sql(name.to_s)
+          elsif klass.respond_to? "#{name}__sql"
+            relation_query = relation_query.select Arel::Nodes::As.new Arel.sql(klass.send("#{name}__sql")), Arel.sql(name.to_s)
+          else
+            relation_query = relation_query.select(relation_query_arel[name])
+          end
+        end
+      end
+
+      if foreign_key_column && constraining_table
+        relation_query = relation_query.where(relation_query_arel[foreign_key_column].in(constraining_table.project(constraining_table[:id])))
+      end
+
+      associations = serializer_class._associations
+      association_sql_tables = []
+      ids_table_name = nil
+      id_query = nil
+      unless associations.empty?
+        ids_table_name = "#{relation.table_name}_ids"
+        ids_table_arel =  Arel::Table.new ids_table_name
+        id_query = relation.dup.select(:id)
+        if foreign_key_column && constraining_table
+          id_query.where!(relation_query_arel[foreign_key_column].in(constraining_table.project(constraining_table[:id])))
+        end
+      end
+
+      associations.each do |key, association_class|
+        association = association_class.new key, _serializer, options
+
+        association_reflection = klass.reflect_on_association(key)
+        if association.embed_ids?
+          if association_reflection.macro == :has_many
+            unless @_ctes.find { |as| as.left == ids_table_name }
+              @_ctes << _postgres_cte_as(ids_table_name, "(#{id_query.to_sql})")
+            end
+            association_sql_tables << _process_has_many_relation(key, association_reflection, relation_query, ids_table_arel)
+          else
+            relation_query = relation_query.select(relation_query_arel["#{key}_id"])
+          end
+        end
+
+        if association.embed_in_root? && !@_embedded.member?(key.to_s)
+          _include_relation_in_root(association_reflection.klass,association_reflection.foreign_key,ids_table_arel)
+        end
+      end
+      arel = relation_query.arel.dup
+
+      association_sql_tables.each do |assoc_hash|
+        assoc_table = Arel::Table.new assoc_hash[:table]
+        arel.join(assoc_table, Arel::Nodes::OuterJoin).on(relation_query_arel[:id].eq(assoc_table[assoc_hash[:foreign_key]]))
+        arel.project _coalesce_arrays(assoc_table[assoc_hash[:ids_column]], assoc_hash[:ids_column])
+      end
+
+      _arel_to_json_array_arel(arel, relation_query.table_name)
+    end
+
+    def _process_has_many_relation(key, association_reflection, relation_query, ids_table_arel)
+      association_class = association_reflection.klass
+      association_arel_table = association_class.arel_table
+      association_query = association_class.group association_arel_table[association_reflection.foreign_key]
+      association_query = association_query.select(association_arel_table[association_reflection.foreign_key])
+      id_column_name = "#{key.to_s.singularize}_ids"
+      cte_name = "#{id_column_name}_by_#{relation_query.table_name}"
+      association_query = association_query.select(_array_agg(association_arel_table[:id], id_column_name))
+      association_query = association_query.having(association_arel_table[association_reflection.foreign_key].in(ids_table_arel.project(ids_table_arel[:id])))
+      @_ctes << _postgres_cte_as(cte_name, "(#{association_query.to_sql})")
+      { table: cte_name, ids_column: id_column_name, foreign_key: association_reflection.foreign_key }
+    end
+
+    def _visitor
+      @_visitior ||= object.klass.connection.visitor
+    end
+
+    def _serializer_class(klass)
+      klass.active_model_serializer
+    end
+
+    def _coalesce_arrays(column, aliaz = nil)
+      _postgres_function_node 'coalesce', [column, Arel.sql("'{}'::int[]")], aliaz
+    end
+
+    def _results_table_arel
+      first = @_results_tables.shift
+      first_table = Arel::Table.new first[:table]
+      jsons_select = first_table.project first_table[first[:column]]
+
+      @_results_tables.each do |table_info|
+        table = Arel::Table.new table_info[:table]
+        jsons_select = jsons_select.project table[table_info[:column]]
+        jsons_select.join(table).on(first_table[:match].eq(table[:match]))
+      end
+
+      @_ctes << _postgres_cte_as('jsons', _visitor.accept(jsons_select))
+
+      jsons_table = Arel::Table.new 'jsons'
+      jsons_row_to_json = _row_to_json jsons_table.name
+      jsons_table.project jsons_row_to_json
+    end
+
+    def _arel_to_json_array_arel(arel, name)
+      json_table = Arel::Table.new "#{name}_attributes_filter"
+      json_select_manager = json_table.project _results_as_json_array(json_table.name, name)
+      json_select_manager.project Arel::Nodes::As.new Arel.sql('1'), Arel.sql('match')
+
+      @_ctes << _postgres_cte_as(json_table.name, _visitor.accept(arel))
+      @_ctes << _postgres_cte_as("#{name}_as_json_array", _visitor.accept(json_select_manager))
+      @_results_tables << { table: "#{name}_as_json_array", column: name }
+    end
+
+    def _relation_to_json_array_arel(relation)
+      json_table = Arel::Table.new "#{relation.table_name}_json"
+      json_select_manager = json_table.project _results_as_json_array(json_table.name, relation.table_name)
+
+      @_ctes << _postgres_cte_as(json_table.name, "(#{relation.to_sql})")
+
+      json_select_manager
+    end
+
+    def _row_to_json(table_name, aliaz = nil)
+      _postgres_function_node 'row_to_json', [Arel.sql(table_name)], aliaz
+    end
+
+    def _postgres_cte_as(name, sql_string)
+      Arel::Nodes::As.new Arel.sql(name), Arel.sql(sql_string)
+    end
+
+    def _results_as_json_array(table_name, aliaz = nil)
+      row_as_json = _row_to_json table_name
+      array_of_json = _postgres_function_node 'array_agg', [row_as_json]
+      _postgres_function_node 'array_to_json', [array_of_json], aliaz
+    end
+
+    def _array_agg(column, aliaz = nil)
+       _postgres_function_node 'array_agg', [column], aliaz
+    end
+
+    def _array_agg_as_json(column, aliaz = nil)
+      array_agg = _array_agg [column]
+      _postgres_function_node 'array_to_json', [array_agg], aliaz
+    end
+
+    def _postgres_function_node(name, values, aliaz = nil)
+      Arel::Nodes::NamedFunction.new(name, values, aliaz)
+    end
+  end
+end
+

data/lib/postgres_ext/serializers/version.rb

@@ -0,0 +1,5 @@
+module PostgresExt
+  module Serializers
+    VERSION = "0.0.1"
+  end
+end

data/postgres_ext-serializers.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'postgres_ext/serializers/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "postgres_ext-serializers"
+  spec.version       = PostgresExt::Serializers::VERSION
+  spec.authors       = ["Dan McClain"]
+  spec.email         = ["git@danmcclain.net"]
+  spec.summary       = %q{Harness the power of PostgreSQL when crafting JSON reponses }
+  spec.description   = %q{}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency     'postgres_ext', '~> 2.1.0'
+  spec.add_runtime_dependency     'active_model_serializers'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'actionpack', '~> 4.0.0'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'm'
+  spec.add_development_dependency 'bourne', '~> 1.3.0'
+  spec.add_development_dependency 'database_cleaner'
+  spec.add_development_dependency 'dotenv'
+  if RUBY_PLATFORM =~ /java/
+    spec.add_development_dependency 'activerecord-jdbcpostgresql-adapter', '1.3.0.beta2'
+  else
+    spec.add_development_dependency 'pg', '~> 0.13.2'
+  end
+end

data/test/serializer_test.rb

@@ -0,0 +1,24 @@
+require 'test_helper'
+
+
+describe 'ArraySerializer patch' do
+  let(:json_data)  { ActiveModel::Serializer.build_json(controller, relation, {}).to_json }
+
+  context 'computed value methods' do
+    let(:relation)   { Person.all }
+    let(:controller) { PeopleController.new }
+    let(:person)     { Person.create first_name: 'Test', last_name: 'User' }
+
+    it 'generates the proper json output for the serializer' do
+      json_expected = %{{"people":[{"id":#{person.id},"full_name":"Test User","attendance_name":"User, Test"}]}}
+      json_data.must_equal json_expected
+    end
+
+    it 'passes scope to the serializer method' do
+      controller.stubs(:current_user).returns({ admin: true })
+
+      json_expected = %{{"people":[{"id":#{person.id},"full_name":"Test User","attendance_name":"ADMIN User, Test"}]}}
+      json_data.must_equal json_expected
+    end
+  end
+end

data/test/sideloading_test.rb

@@ -0,0 +1,52 @@
+
+describe 'ArraySerializer patch' do
+  let(:json_data)  { ActiveModel::Serializer.build_json(controller, relation, {}).to_json }
+
+  context 'no where clause on root relation' do
+    let(:relation)   { Note.all }
+    let(:controller) { NotesController.new }
+
+    before do
+      note_1 = Note.create name: 'test', content: 'dummy content'
+      note_2 = Note.create name: 'test 2', content: 'dummy content'
+
+      tag    = Tag.create name: 'tag 1', note_id: note_1.id
+      Tag.create name: 'tag 2'
+      @json_expected = "{\"tags\":[{\"id\":#{tag.id},\"name\":\"tag 1\",\"note_id\":#{note_1.id}}],\"notes\":[{\"id\":#{note_1.id},\"content\":\"dummy content\",\"name\":\"test\",\"tag_ids\":[#{tag.id}]},{\"id\":#{note_2.id},\"content\":\"dummy content\",\"name\":\"test 2\",\"tag_ids\":[]}]}"
+    end
+
+    it 'generates the proper json output for the serializer' do
+      json_data.must_equal @json_expected
+    end
+
+    it 'does not instantiate ruby objects for relations' do
+      relation.stubs(:to_a).returns([])
+      json_data
+      assert_received(relation, :to_a) { |expect| expect.never}
+    end
+  end
+
+  context 'where clause on root relation' do
+    let(:relation)   { Note.where(name: 'test') }
+    let(:controller) { NotesController.new }
+
+    before do
+      note_1 = Note.create name: 'test', content: 'dummy content'
+      note_2 = Note.create name: 'test 2', content: 'dummy content'
+
+      tag    = Tag.create name: 'tag 1', note_id: note_1.id
+      Tag.create name: 'tag 2', note_id: note_2.id
+      @json_expected = "{\"tags\":[{\"id\":#{tag.id},\"name\":\"tag 1\",\"note_id\":#{note_1.id}}],\"notes\":[{\"id\":#{note_1.id},\"content\":\"dummy content\",\"name\":\"test\",\"tag_ids\":[#{tag.id}]}]}"
+    end
+
+    it 'generates the proper json output for the serializer' do
+      json_data.must_equal @json_expected
+    end
+
+    it 'does not instantiate ruby objects for relations' do
+      relation.stubs(:to_a).returns([])
+      json_data
+      assert_received(relation, :to_a) { |expect| expect.never}
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,81 @@
+require 'active_record'
+require 'minitest/autorun'
+require 'test/unit'
+require 'mocha/setup'
+require 'bourne'
+require 'database_cleaner'
+unless ENV['CI'] || RUBY_PLATFORM =~ /java/
+  require 'byebug'
+end
+require 'postgres_ext/serializers'
+
+require 'dotenv'
+Dotenv.load
+
+ActiveRecord::Base.establish_connection
+
+class TestController < ActionController::Base
+  def url_options
+    {}
+  end
+end
+
+class Person < ActiveRecord::Base
+  def self.full_name__sql
+    "first_name || ' ' || last_name"
+  end
+end
+
+class PeopleController < TestController; end
+
+class PersonSerializer < ActiveModel::Serializer
+  attributes :id, :full_name, :attendance_name
+
+  def self.attendance_name__sql(scope)
+    if scope &&  scope[:admin]
+      "'ADMIN ' || last_name || ', ' || first_name"
+    else
+      "last_name || ', ' || first_name"
+    end
+  end
+end
+
+class Note < ActiveRecord::Base
+  has_many :tags
+end
+
+class NotesController < TestController; end
+
+class NoteSerializer < ActiveModel::Serializer
+  attributes :id, :content, :name
+  has_many   :tags
+  embed      :ids, include: true
+end
+
+class Tag < ActiveRecord::Base
+  belongs_to :note
+end
+
+
+
+class TagSerializer < ActiveModel::Serializer
+  attributes :id, :name
+  embed :ids
+  has_one :note
+end
+
+DatabaseCleaner.strategy = :deletion
+
+class MiniTest::Spec
+  class << self
+    alias :context :describe
+  end
+
+  before do
+    DatabaseCleaner.start
+  end
+
+  after do
+    DatabaseCleaner.clean
+  end
+end

metadata

@@ -0,0 +1,214 @@
+--- !ruby/object:Gem::Specification
+name: postgres_ext-serializers
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Dan McClain
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: postgres_ext
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: active_model_serializers
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !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: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.0.0
+- !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: minitest
+  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: m
+  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: bourne
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.3.0
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  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: dotenv
+  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: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.13.2
+description: ''
+email:
+- git@danmcclain.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/postgres_ext/serializers.rb
+- lib/postgres_ext/serializers/active_model.rb
+- lib/postgres_ext/serializers/active_model/array_serializer.rb
+- lib/postgres_ext/serializers/version.rb
+- postgres_ext-serializers.gemspec
+- test/serializer_test.rb
+- test/sideloading_test.rb
+- test/test_helper.rb
+homepage: ''
+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.2.0
+signing_key: 
+specification_version: 4
+summary: Harness the power of PostgreSQL when crafting JSON reponses
+test_files:
+- test/serializer_test.rb
+- test/sideloading_test.rb
+- test/test_helper.rb