storing 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: cb9e623717833ee559b94a421d1e9d5dc09abd16
+  data.tar.gz: 5bf793aecad4f3feee07cfc09addec3f04b58aec
+SHA512:
+  metadata.gz: 37b4a7c8a7a4fc734c58cdcbc803193b13aedca68fe1e7d6e4c90f4224044b168a8b4a0c88e1db39a019f4e94223bc6ad88efe28f0357fcbb1e67d8ce419d210
+  data.tar.gz: f98e2341b7d7e01c5cd11a821f24fe1a59d9d270a9623f9e90437440fb82e01b7c3bfa9ceefe278e9d7add9a5c3bf3317d38d656ea96e808b9edb080b5edd730

data/.gitignore

@@ -0,0 +1,17 @@
+*.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/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in storing.gemspec
+gemspec

data/Guardfile

@@ -0,0 +1,9 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+guard :minitest, :all_on_start => false do
+	# with Minitest::Spec
+	watch(%r{^spec/(.*)_spec\.rb})
+	watch(%r{^lib/(.+)\.rb})         { |m| "spec/lib/#{m[1]}_spec.rb" }
+	watch(%r{^spec/spec_helper\.rb}) { 'spec' }
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Erik Lott
+
+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,29 @@
+# Storing
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'storing'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install storing
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/storing/abstract_adaptor.rb

@@ -0,0 +1,23 @@
+module Storing
+	class AbstractAdaptor
+		def query query_obj
+			raise NotImplementedError
+		end
+
+		def insert table_name, params={}
+			raise NotImplementedError
+		end
+
+		def update table_name, conditions={}, params={}
+			raise NotImplementedError
+		end
+
+		def delete table_name, conditions={}
+			raise NotImplementedError
+		end
+
+		def transaction &block
+			raise NotImplementedError
+		end
+	end
+end

data/lib/storing/dataset.rb

@@ -0,0 +1,74 @@
+require 'storing/exceptions'
+
+module Storing
+	class Dataset
+		class PrimaryKey
+			def self.from_hash key, params={}
+				keys = [*key]
+				values = params.values_at(*keys)
+				new(keys, values)
+			end
+
+			attr_reader :key, :value
+
+			def initialize key, value=nil
+				@key = key
+				@value = value
+			end
+
+			def to_hash
+				output = {}
+				keys.length.times do |i|
+					output[keys[i]] = values[i]
+				end
+				output
+			end
+
+			def reject_from params={}
+				params.reject{ |k,v| keys.include?(k) }
+			end
+
+			private
+
+			def keys
+				[*key]
+			end
+
+			def values
+				[*value]
+			end
+		end
+
+		attr_reader :adaptor, :table_name, :primary_key_column
+
+		def initialize adaptor, table_name, primary_key_column
+			@adaptor = adaptor
+			@table_name = table_name
+			@primary_key_column = primary_key_column
+		end
+
+		def insert params={}
+			primary_key_value = adaptor.insert(table_name, params)
+			::Storing::Dataset::PrimaryKey.new(primary_key_column, primary_key_value).to_hash
+		end
+
+		def update params={}
+			primary_key = ::Storing::Dataset::PrimaryKey.from_hash(primary_key_column, params)
+			filtered_params = primary_key.reject_from(params)
+			update_where(primary_key.to_hash, filtered_params)
+		end
+
+		def update_where conditions={}, params={}
+			adaptor.update(table_name, conditions, params)
+		end
+
+		def delete params={}
+			primary_key = ::Storing::Dataset::PrimaryKey.from_hash(primary_key_column, params)
+			delete_where(primary_key.to_hash)
+		end
+
+		def delete_where conditions={}
+			adaptor.delete(table_name, conditions)
+		end
+	end
+end

data/lib/storing/entity_store.rb

@@ -0,0 +1,64 @@
+require 'storing/exceptions'
+require 'storing/dataset'
+
+module Storing
+	class EntityStore
+		module Extension
+			def self.included(base)
+				base.extend ClassMethods
+			end
+
+			module ClassMethods
+				def set_primary_key val
+					@primary_key = val
+				end
+
+				def primary_key
+					@primary_key || raise(MissingPrimaryKey, 'primary key not assigned')
+				end
+
+				def set_table_name val
+					@table_name = val
+				end
+
+				def table_name
+					@table_name || raise(MissingTableName, 'table name not assigned')
+				end
+			end
+
+			attr_reader :adaptor
+
+			def initialize adaptor
+				@adaptor = adaptor
+			end
+
+			def insert *args
+				dataset.insert *args
+			end
+
+			def update *args
+				dataset.update *args
+			end
+
+			def update_where *args
+				dataset.update_where *args
+			end
+
+			def delete *args
+				dataset.delete *args
+			end
+
+			def delete_where *args
+				dataset.delete_where *args
+			end
+
+			private
+
+			def dataset
+				::Storing::Dataset.new(adaptor, self.class.table_name, self.class.primary_key)
+			end
+		end
+
+		include Extension
+	end
+end

data/lib/storing/exceptions.rb

@@ -0,0 +1,6 @@
+module Storing
+	class StoringError < StandardError; end
+	class BadPrimaryKey < StoringError; end
+	class MissingTableName < StoringError; end
+	class MissingPrimaryKey < StoringError; end
+end

data/lib/storing/postgres/abstract_queries/abstract_query.rb

@@ -0,0 +1,9 @@
+module Storing
+	module Postgres
+		class AbstractQuery
+			def to_sql database
+				raise NotImplementedError
+			end
+		end
+	end
+end

data/lib/storing/postgres/abstract_queries/abstract_select_query.rb

@@ -0,0 +1,27 @@
+require 'storing/postgres/abstract_queries/abstract_query'
+
+module Storing
+	module Postgres
+		class AbstractSelectQuery < AbstractQuery
+			attr_reader :query_object
+
+			def initialize query_object=nil
+				@query_object = query_object
+			end
+
+			def query database
+				raise NotImplementedError
+			end
+
+			def to_sql database
+				query(database).select_sql
+			end
+
+			private
+
+			def call_query_chain database
+				query_object ? query_object.query(database) : database
+			end
+		end
+	end
+end

data/lib/storing/postgres/adaptor.rb

@@ -0,0 +1,58 @@
+require 'sequel'
+require 'storing/abstract_adaptor'
+require 'storing/postgres/queries/insert_query'
+require 'storing/postgres/queries/update_query'
+require 'storing/postgres/queries/delete_query'
+
+module Storing
+	module Postgres
+		class Adaptor < ::Storing::AbstractAdaptor
+			QUERY_METHOD_MAP = {
+				:select => :all,
+				:insert => :insert,
+				:update => :update,
+				:delete => :delete
+			}.freeze
+
+			attr_reader :database
+
+			def connect *args
+				new Sequel.postgres(*args)
+			end
+
+			def initialize database
+				@database = database
+			end
+
+			def query query_object
+				execute_query(query_object, :select)
+			end
+
+			def insert table_name, params={}
+				execute_query(InsertQuery.new(table_name, params), :insert)
+			end
+
+			def update table_name, conditions={}, params={}
+				execute_query(UpdateQuery.new(table_name, conditions, params), :update)
+			end
+
+			def delete table_name, conditions={}
+				execute_query(DeleteQuery.new(table_name, conditions), :delete)
+			end
+
+			def transaction
+				database.transaction
+			end
+
+			private
+
+			def execute_query query_object, type=:select
+				execute(query_object.to_sql(database), type)
+			end
+
+			def execute sql, type=:select
+				database[sql].send(QUERY_METHOD_MAP.fetch(type))
+			end
+		end
+	end
+end

data/lib/storing/postgres/queries/delete_query.rb

@@ -0,0 +1,16 @@
+require 'storing/postgres/abstract_queries/abstract_query'
+
+module Storing
+	module Postgres
+		class DeleteQuery < ::Storing::Postgres::AbstractQuery
+			def initialize table_name, conditions={}
+				@table_name = table_name
+				@conditions = conditions
+			end
+
+			def to_sql database
+				database[@table_name].where(@conditions).delete_sql
+			end
+		end
+	end
+end

data/lib/storing/postgres/queries/insert_query.rb

@@ -0,0 +1,16 @@
+require 'storing/postgres/abstract_queries/abstract_query'
+
+module Storing
+	module Postgres
+		class InsertQuery < ::Storing::Postgres::AbstractQuery
+			def initialize table_name, params={}
+				@table_name = table_name
+				@params = params
+			end
+
+			def to_sql database
+				database[@table_name].insert_sql(@params)
+			end
+		end
+	end
+end

data/lib/storing/postgres/queries/update_query.rb

@@ -0,0 +1,17 @@
+require 'storing/postgres/abstract_queries/abstract_query'
+
+module Storing
+	module Postgres
+		class UpdateQuery < ::Storing::Postgres::AbstractQuery
+			def initialize table_name, conditions={}, params={}
+				@table_name = table_name
+				@conditions = conditions
+				@params = params
+			end
+
+			def to_sql database
+				database[@table_name].where(@conditions).update_sql(@params)
+			end
+		end
+	end
+end

data/lib/storing/version.rb

@@ -0,0 +1,3 @@
+module Storing
+ 	VERSION = "0.0.1"
+end

data/lib/storing.rb

@@ -0,0 +1,4 @@
+require "storing/version"
+
+module Storing
+end

data/spec/dataset_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+require 'storing/dataset' 
+
+describe Storing::Dataset do
+	let(:table_name){ 'users' }
+	let(:adaptor){ stub }
+	let(:primary_key_column){ [:user_id, :user_type] }
+	let(:store){ Storing::Dataset.new(adaptor, table_name, primary_key_column) }
+
+	describe "#insert" do
+		let(:params){stub}
+
+		it "passes params to adaptor" do
+			adaptor.expects(:insert).with(table_name, params).returns([123, 'person'])
+			store.insert(params)
+		end
+
+		it "returns primary key hash" do
+			adaptor.expects(:insert).returns([123, 'person'])
+			store.insert(params).must_equal({:user_id=>123, :user_type=>"person"})
+		end
+	end
+
+	describe "#update" do
+		it "formats params and delegates to update_where method" do
+			params = {:user_id => 123, :user_type => "person", :first_name => 'john', :last_name => 'doe'}
+			store.expects(:update_where).with({:user_id => 123, :user_type => "person"}, {:first_name => 'john', :last_name => 'doe'})
+			store.update(params)
+		end
+	end
+
+	describe "#update_where" do
+		it "delegates to adaptor" do
+			adaptor_response = stub
+			params = stub
+			where = stub
+			adaptor.expects(:update).with(table_name, where, params).returns(adaptor_response)
+			store.update_where(where, params).must_equal(adaptor_response)
+		end
+	end
+
+	describe "#delete" do
+		it "delegates to delete_where method" do
+			params = {:user_id => 123, :user_type => "person", :first_name => 'john', :last_name => 'doe'}
+			store.expects(:delete_where).with({:user_id => 123, :user_type => "person"})
+			store.delete(params)
+		end
+	end
+
+	describe "#delete_where" do
+		it "delegates to adaptor" do
+			adaptor_response = stub
+			where = stub
+			adaptor.expects(:delete).with(table_name, where).returns(adaptor_response)
+			store.delete_where(where).must_equal(adaptor_response)
+		end
+	end
+end
+
+describe Storing::Dataset::PrimaryKey do
+	describe "#to_hash" do
+		it "returns hash version of primary key" do
+			pk = Storing::Dataset::PrimaryKey.new(:user_id, 123)
+			pk.to_hash.must_equal({:user_id => 123})
+
+			pk = Storing::Dataset::PrimaryKey.new([:user_id, :user_type], [123, 'person'])
+			pk.to_hash.must_equal({:user_id=>123, :user_type=>"person"})
+		end
+	end
+
+	describe "::from_hash" do
+		it "creates pk from hash" do
+			pk = Storing::Dataset::PrimaryKey.from_hash(:user_id, :user_id => 123, :name => 'john doe')
+			pk.key.must_equal [:user_id]
+			pk.value.must_equal [123]
+		end
+	end
+
+	describe "#reject_from" do
+		it "removes primary key from params" do
+			pk = Storing::Dataset::PrimaryKey.new([:user_id, :user_type])
+			pk.reject_from({
+				:user_id => 123, 
+				:user_type => 'person',
+				:name => 'john doe'
+			}).must_equal({:name => 'john doe'})
+		end
+	end
+end

data/spec/entity_store_spec.rb

@@ -0,0 +1,71 @@
+require 'spec_helper'
+require 'storing/entity_store'
+
+describe Storing::EntityStore::Extension do
+	let(:adaptor){stub}
+	let(:store_class) do
+		Class.new{ 
+			include Storing::EntityStore::Extension 
+			set_table_name :user
+			set_primary_key :user_id
+		}
+	end
+	let(:store) { store_class.new(adaptor) }
+
+	describe "::set_primary_key" do
+		it "sets primary key on class" do
+			store_class.set_primary_key :subscription_id
+			store_class.primary_key.must_equal :subscription_id
+		end
+	end
+
+	describe "::set_table_name" do
+		it "sets primary key on class" do
+			store_class.set_table_name :subscription
+			store_class.table_name.must_equal :subscription
+		end
+	end
+
+	describe "instance methods" do
+		let(:dataset){ stub }
+
+		before do
+			store.expects(:dataset).returns(dataset)
+		end
+	
+		describe "#insert" do
+			it "delegates to dataset" do
+				dataset.expects(:insert).with('blah')
+				store.insert('blah')
+			end
+		end
+
+		describe "#update" do
+			it "delegates to dataset" do
+				dataset.expects(:update).with('blah')
+				store.update('blah')
+			end
+		end
+
+		describe "#update_where" do
+			it "delegates to dataset" do
+				dataset.expects(:update_where).with('blah')
+				store.update_where('blah')
+			end
+		end
+
+		describe "#delete" do
+			it "delegates to dataset" do
+				dataset.expects(:delete).with('blah')
+				store.delete('blah')
+			end
+		end
+
+		describe "#delete_where" do
+			it "delegates to dataset" do
+				dataset.expects(:delete_where).with('blah')
+				store.delete_where('blah')
+			end
+		end
+	end
+end

data/spec/postgres/adaptor/delete_query_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'storing/postgres/queries/delete_query'
+
+describe Storing::Postgres::DeleteQuery do
+	describe "to_sql" do
+		it "returns insert sql" do
+			query = Storing::Postgres::DeleteQuery.new(:user, :user_id => 123)
+			query.to_sql(DB).must_equal "DELETE FROM \"user\" WHERE (\"user_id\" = 123)"
+		end
+	end
+end

data/spec/postgres/adaptor/insert_query_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+require 'storing/postgres/queries/insert_query'
+
+describe Storing::Postgres::InsertQuery do
+	describe "to_sql" do
+		it "returns insert sql" do
+			query = Storing::Postgres::InsertQuery.new(:user, :user_id => 123, :name => 'John Doe', :age => 35)
+			query.to_sql(DB).must_equal "INSERT INTO \"user\" (\"user_id\", \"name\", \"age\") VALUES (123, 'John Doe', 35)"
+		end
+	end
+end

data/spec/postgres/adaptor/update_query_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+require 'storing/postgres/queries/update_query'
+
+describe Storing::Postgres::UpdateQuery do
+	describe "to_sql" do
+		it "returns insert sql" do
+			conditions = {:user_id => 123}
+			params = {:name => 'John Doe', :age => 35}
+			query = Storing::Postgres::UpdateQuery.new(:user, conditions, params)
+			query.to_sql(DB).must_equal "UPDATE \"user\" SET \"name\" = 'John Doe', \"age\" = 35 WHERE (\"user_id\" = 123)"
+		end
+	end
+end

data/spec/postgres/adaptor_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'storing/postgres/adaptor'
+
+describe Storing::Postgres::Adaptor do
+	describe "#insert" do
+		it "delegates to execute_query method" do
+			table_name = stub
+			params = stub
+			query_object = stub
+
+			Storing::Postgres::InsertQuery.expects(:new).with(table_name, params).returns(query_object)
+			adaptor = Storing::Postgres::Adaptor.new(DB)
+			adaptor.expects(:execute_query).with(query_object, :insert)
+			adaptor.insert(table_name, params)
+		end
+	end
+
+	describe "#update" do
+		it "delegates to execute_query method" do
+			table_name = stub
+			conditions = stub
+			params = stub
+			query_object = stub
+
+			Storing::Postgres::UpdateQuery.expects(:new).with(table_name, conditions, params).returns(query_object)
+			adaptor = Storing::Postgres::Adaptor.new(DB)
+			adaptor.expects(:execute_query).with(query_object, :update)
+			adaptor.update(table_name, conditions, params)
+		end
+	end
+
+	describe "#delete" do
+		it "delegates to execute_query method" do
+			table_name = stub
+			conditions = stub
+			query_object = stub
+
+			Storing::Postgres::DeleteQuery.expects(:new).with(table_name, conditions).returns(query_object)
+			adaptor = Storing::Postgres::Adaptor.new(DB)
+			adaptor.expects(:execute_query).with(query_object, :delete)
+			adaptor.delete(table_name, conditions)
+		end
+	end
+
+	describe "#query" do
+		it "delegates to execute_query method" do
+			query_object = stub
+
+			adaptor = Storing::Postgres::Adaptor.new(DB)
+			adaptor.expects(:execute_query).with(query_object, :select)
+			adaptor.query(query_object)
+		end
+	end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'minitest/autorun'
+require 'mocha/setup'
+require 'sequel'
+
+DB = Sequel.connect("postgres://admin:Zbx8L9W33E@localhost/gazou_postgres_test", :encoding => 'unicode')
+
+require 'database_cleaner'
+
+DatabaseCleaner.strategy = :transaction
+
+class MiniTest::Spec
+	before :each do
+		DatabaseCleaner.start
+		DB[:source_type].insert(:source_type_code => 'S3', :name => 'amazons3source')
+	end
+
+	after :each do
+		DatabaseCleaner.clean
+	end
+end

data/storing.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'storing/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "storing"
+  spec.version       = Storing::VERSION
+  spec.authors       = ["Erik Lott"]
+  spec.email         = ["erik.lott@kodio.com"]
+  spec.description   = %q{Minimal storage interface}
+  spec.summary       = %q{General storage interface}
+  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_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "guard-minitest", "~> 2.0.0"
+  spec.add_development_dependency "mocha", "~> 0.14.0"
+  spec.add_development_dependency "database_cleaner", "~> 1.2.0"
+  spec.add_development_dependency "sequel", "~> 4.3.0"
+  spec.add_development_dependency "pg", "~> 0.17.0"
+end

metadata

@@ -0,0 +1,175 @@
+--- !ruby/object:Gem::Specification
+name: storing
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Erik Lott
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-27 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: guard-minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.14.0
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: sequel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.3.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 4.3.0
+- !ruby/object:Gem::Dependency
+  name: pg
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+description: Minimal storage interface
+email:
+- erik.lott@kodio.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/storing.rb
+- lib/storing/abstract_adaptor.rb
+- lib/storing/dataset.rb
+- lib/storing/entity_store.rb
+- lib/storing/exceptions.rb
+- lib/storing/postgres/abstract_queries/abstract_query.rb
+- lib/storing/postgres/abstract_queries/abstract_select_query.rb
+- lib/storing/postgres/adaptor.rb
+- lib/storing/postgres/queries/delete_query.rb
+- lib/storing/postgres/queries/insert_query.rb
+- lib/storing/postgres/queries/update_query.rb
+- lib/storing/version.rb
+- spec/dataset_spec.rb
+- spec/entity_store_spec.rb
+- spec/postgres/adaptor/delete_query_spec.rb
+- spec/postgres/adaptor/insert_query_spec.rb
+- spec/postgres/adaptor/update_query_spec.rb
+- spec/postgres/adaptor_spec.rb
+- spec/spec_helper.rb
+- storing.gemspec
+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.0.7
+signing_key: 
+specification_version: 4
+summary: General storage interface
+test_files:
+- spec/dataset_spec.rb
+- spec/entity_store_spec.rb
+- spec/postgres/adaptor/delete_query_spec.rb
+- spec/postgres/adaptor/insert_query_spec.rb
+- spec/postgres/adaptor/update_query_spec.rb
+- spec/postgres/adaptor_spec.rb
+- spec/spec_helper.rb