storing 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: cb9e623717833ee559b94a421d1e9d5dc09abd16
-  data.tar.gz: 5bf793aecad4f3feee07cfc09addec3f04b58aec
+  metadata.gz: 13109e121a21eb09c874b455d967b07e0fedbc48
+  data.tar.gz: 4876e62b5f58c6025e92de2479804bf3011d5fa4
 SHA512:
-  metadata.gz: 37b4a7c8a7a4fc734c58cdcbc803193b13aedca68fe1e7d6e4c90f4224044b168a8b4a0c88e1db39a019f4e94223bc6ad88efe28f0357fcbb1e67d8ce419d210
-  data.tar.gz: f98e2341b7d7e01c5cd11a821f24fe1a59d9d270a9623f9e90437440fb82e01b7c3bfa9ceefe278e9d7add9a5c3bf3317d38d656ea96e808b9edb080b5edd730
+  metadata.gz: 0ca4a961a790fb3c124d845405da607b70246a617042f8ec0595f1b827c3718d7554807591800c24e6e45c39ff92ccf6953e84cdf8ba2d7ee3eb02cf5c299c21
+  data.tar.gz: abd06f54129e03fc7a39e6a7985ccbcfc18e463811eb4b8d923838cb5b0d0a04d6748c65b6bf28a685b9b8203811475a736387c1c439130e89737a1b32b00600

data/.gitignore

@@ -3,7 +3,9 @@
 .bundle
 .config
 .yardoc
+.env
 Gemfile.lock
+Guardfile
 InstalledFiles
 _yardoc
 coverage
@@ -14,4 +16,4 @@ rdoc
 spec/reports
 test/tmp
 test/version_tmp
-tmp
+tmp

data/lib/storing/{abstract_adaptor.rb → abstract/abstract_adaptor.rb}

@@ -1,6 +1,10 @@
 module Storing
 	class AbstractAdaptor
-		def query query_obj
+		def query query_object
+			raise NotImplementedError
+		end
+
+		def select table_name, conditions={}
 			raise NotImplementedError
 		end
 

data/lib/storing/abstract/abstract_deleter.rb

@@ -0,0 +1,7 @@
+module Storing
+	class AbstractDeleter
+		def delete
+			raise NotImplementedError
+		end
+	end
+end

data/lib/storing/abstract/abstract_inserter.rb

@@ -0,0 +1,7 @@
+module Storing
+	class AbstractInserter
+		def insert
+			raise NotImplementedError
+		end
+	end
+end

data/lib/storing/abstract/abstract_mapper.rb

@@ -0,0 +1,11 @@
+module Storing
+	class AbstractMapper
+		def self.parse data={}
+			raise NotImplementedError
+		end
+
+		def self.dump_to_table entity, table_name
+			raise NotImplementedError 
+		end
+	end
+end

data/lib/storing/abstract/abstract_query.rb

@@ -0,0 +1,7 @@
+module Storing
+	class AbstractQuery
+		def query
+			raise NotImplementedError
+		end
+	end
+end

data/lib/storing/abstract/abstract_store.rb

@@ -0,0 +1,35 @@
+module Storing
+	class AbstractStore
+		def query query_obj
+			raise NotImplementedError
+		end
+
+		def select conditions={}
+			raise NotImplementedError
+		end
+
+		def insert entity_hash={}
+			raise NotImplementedError
+		end
+
+		def update entity_hash={}
+			raise NotImplementedError
+		end
+
+		def delete entity_hash={}
+			raise NotImplementedError
+		end
+
+		def transaction
+			raise NotImplementedError
+		end
+
+		def table_name
+			raise NotImplementedError
+		end
+
+		def primary_key
+			raise NotImplementedError
+		end
+	end
+end

data/lib/storing/abstract/abstract_updater.rb

@@ -0,0 +1,7 @@
+module Storing
+	class AbstractUpdater
+		def update
+			raise NotImplementedError
+		end
+	end
+end

data/lib/storing/deleter.rb

@@ -0,0 +1,28 @@
+require 'storing/deleters/abstract_deleter'
+
+module Storing
+	class Deleter < AbstractDeleter
+
+		attr_reader :entity, :mapper, :store
+
+		def initialize entity, mapper, store
+			@entity = entity
+			@mapper = mapper
+			@store = store
+		end
+
+		def insert
+			store.delete(data)
+		end
+
+		private
+
+		def data
+			mapper.dump_to_table(entity, table_name)
+		end
+
+		def table_name
+			store.table_name
+		end
+	end
+end

data/lib/storing/inserter.rb

@@ -0,0 +1,28 @@
+require 'storing/inserters/abstract_inserter'
+
+module Storing
+	class Inserter < AbstractInserter
+
+		attr_reader :entity, :mapper, :store
+
+		def initialize entity, mapper, store
+			@entity = entity
+			@mapper = mapper
+			@store = store
+		end
+
+		def insert
+			store.insert(data)
+		end
+
+		private
+
+		def data
+			mapper.dump_to_table(entity, table_name)
+		end
+
+		def table_name
+			store.table_name
+		end
+	end
+end

data/lib/storing/postgres/{abstract_queries/abstract_select_query.rb → abstract_query.rb}

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

data/lib/storing/postgres/adaptor.rb

@@ -1,19 +1,9 @@
 require 'sequel'
-require 'storing/abstract_adaptor'
-require 'storing/postgres/queries/insert_query'
-require 'storing/postgres/queries/update_query'
-require 'storing/postgres/queries/delete_query'
+require 'storing/abstract/abstract_adaptor'
 
 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
@@ -25,33 +15,27 @@ module Storing
 			end
 
 			def query query_object
-				execute_query(query_object, :select)
-			end
-
-			def insert table_name, params={}
-				execute_query(InsertQuery.new(table_name, params), :insert)
+				database[query_object.query(database)].all
 			end
 
-			def update table_name, conditions={}, params={}
-				execute_query(UpdateQuery.new(table_name, conditions, params), :update)
+			def select table_name, conditions={}
+				database[table_name].where(conditions).all
 			end
 
-			def delete table_name, conditions={}
-				execute_query(DeleteQuery.new(table_name, conditions), :delete)
+			def insert table_name, params={}
+				database[table_name].insert(params)
 			end
 
-			def transaction
-				database.transaction
+			def update table_name, params={}, conditions={}
+				database[table_name].where(conditions).update(params)
 			end
 
-			private
-
-			def execute_query query_object, type=:select
-				execute(query_object.to_sql(database), type)
+			def delete table_name, conditions={}
+				database[table_name].where(conditions).delete
 			end
 
-			def execute sql, type=:select
-				database[sql].send(QUERY_METHOD_MAP.fetch(type))
+			def transaction &block
+				database.transaction &block
 			end
 		end
 	end

data/lib/storing/store.rb

@@ -0,0 +1,96 @@
+require 'storing/abstract/abstract_store'
+require 'storing/exceptions'
+
+module Storing
+	class Store < AbstractStore
+		class Entity
+			attr_reader :primary_key_column, :data
+
+			def initialize primary_key_column, data={}
+				@primary_key_column = primary_key_column
+				@data = data
+			end
+
+			def primary_key_hash
+				primary_key_columns.inject({}) do |memo, pk_col|
+					memo[pk_col] = data.fetch(pk_col)
+					memo
+				end
+			rescue KeyError => e
+				raise(MissingPrimaryKey, 'primary key missing in entity data hash')
+			end
+
+			def params
+				data.reject{|k,v| primary_key_columns.include? k }
+			end
+
+			private
+
+			def primary_key_columns
+				[*primary_key_column]
+			end
+		end
+
+		def self.set_primary_key val
+			@primary_key = val
+		end
+
+		def self.primary_key
+			@primary_key || raise(MissingPrimaryKey, 'primary key not assigned')
+		end
+
+		def self.set_table_name val
+			@table_name = val
+		end
+
+		def self.table_name
+			@table_name || raise(MissingTableName, 'table name not assigned')
+		end
+
+		attr_reader :adaptor
+
+		def initialize adaptor
+			@adaptor = adaptor
+		end
+
+		def query query_object
+			adaptor.query(query_object)
+		end
+
+		def select conditions={}
+			adaptor.select(table_name, conditions)
+		end
+
+		def insert entity_hash={}
+			adaptor.insert(table_name, entity_hash)
+		end
+
+		def update entity_hash={}
+			entity = new_entity(entity_hash)
+			adaptor.update(table_name, entity.params, entity.primary_key_hash)
+		end
+
+		def delete entity_hash={}
+			entity = new_entity(entity_hash)
+			adaptor.delete(table_name, entity.primary_key_hash)
+		end
+
+		def transaction
+			adaptor.transaction
+		end
+
+		def table_name
+			self.class.table_name
+		end
+
+		def primary_key
+			self.class.primary_key
+		end
+
+		private
+
+		def new_entity entity_hash={}
+			::Storing::Store::Entity.new(primary_key, entity_hash)
+		end
+	end
+end

data/lib/storing/updater.rb

@@ -0,0 +1,28 @@
+require 'storing/updaters/abstract_updater'
+
+module Storing
+	class Updater < AbstractUpdater
+
+		attr_reader :entity, :mapper, :store
+
+		def initialize entity, mapper, store
+			@entity = entity
+			@mapper = mapper
+			@store = store
+		end
+
+		def insert
+			store.update(data)
+		end
+
+		private
+
+		def data
+			mapper.dump_to_table(entity, table_name)
+		end
+
+		def table_name
+			store.table_name
+		end
+	end
+end

data/lib/storing/version.rb

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

data/spec/migrate/1382997183_create_person.rb

@@ -0,0 +1,10 @@
+Sequel.migration do
+	change do
+		create_table(:person) do
+			primary_key :person_id
+			String :first_name, :null=>false
+			String :last_name, :null=>false
+			Integer :age, :null=>false
+		end
+	end
+end

data/spec/postgres/adaptor_spec.rb

@@ -2,53 +2,84 @@ 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
+	let(:adaptor) { Storing::Postgres::Adaptor.new(DB) }
+
+	before do
+		DB[:person].insert(:first_name => 'Peter', :last_name => 'Parker', :age => 23)
+		DB[:person].insert(:first_name => 'Tony', :last_name => 'Stark', :age => 37)
+		DB[:person].insert(:first_name => 'Bruce', :last_name => 'Banner', :age => 33)
+	end
+
+	describe "#select" do
+		it "returns all records" do
+			results = adaptor.select(:person)
+			results.map{|p| p[:first_name]}.must_equal ["Peter", "Tony", "Bruce"]
+		end
 
-			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)
+		it "returns records conditionally" do
+			results = adaptor.select(:person, :first_name => 'Peter')
+			results.length.must_equal 1
+		end
+	end
+
+	describe "#insert" do
+		it "inserts record" do
+			adaptor.insert(:person, :first_name => 'Charles', :last_name => 'Xavier', :age => 67)
+			DB[:person][:first_name => 'Charles'].wont_be_nil
 		end
+
+		it "returns primary key" do
+			pk = adaptor.insert(:person, :first_name => 'Charles', :last_name => 'Xavier', :age => 67)
+			pk.to_s.must_match /^\d+$/
+		end	
 	end
 
 	describe "#update" do
-		it "delegates to execute_query method" do
-			table_name = stub
-			conditions = stub
-			params = stub
-			query_object = stub
+		it "updates all records" do
+			adaptor.update(:person, :first_name => 'Jim')
+			DB[:person].each {|person| person[:first_name].must_equal 'Jim' }
+		end
 
-			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)
+		it "updates records conditionally" do
+			adaptor.update(:person, {:first_name => "Pete"}, {:last_name => 'Parker'})
+			DB[:person].map {|person| person[:first_name] }.must_equal ["Tony", "Bruce", "Pete"]
+		end
+
+		it "returns number of rows updated" do
+			adaptor.update(:person, :first_name => 'Jim').must_equal 3
 		end
 	end
 
 	describe "#delete" do
-		it "delegates to execute_query method" do
-			table_name = stub
-			conditions = stub
-			query_object = stub
+		it "deletes all records" do
+			adaptor.delete(:person)
+			DB[:person].all.length.must_equal 0
+		end
 
-			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)
+		it "deletes records conditionally" do
+			adaptor.delete(:person, :first_name => "Tony")
+			DB[:person].map {|person| person[:first_name] }.must_equal ["Peter", "Bruce"]
+		end
+
+		it "returns number of rows deleted" do
+			adaptor.delete(:person, :first_name => "Tony").must_equal 1
 		end
 	end
 
 	describe "#query" do
-		it "delegates to execute_query method" do
-			query_object = stub
+		it "returns selected records" do
+			query_object = stub(:query => "SELECT * FROM person LIMIT 2")
+			result = adaptor.query(query_object)
+			result.map {|person| person[:first_name] }.must_equal ["Peter", "Tony"]
+		end
+	end
 
-			adaptor = Storing::Postgres::Adaptor.new(DB)
-			adaptor.expects(:execute_query).with(query_object, :select)
-			adaptor.query(query_object)
+	describe "#transaction" do
+		it "yields transaction to sequel" do
+			adaptor.transaction do
+				adaptor.update(:person, :first_name => 'Jim')
+				adaptor.delete(:person, :last_name => "Stark")
+			end
 		end
 	end
 end

data/spec/spec_helper.rb

@@ -1,17 +1,15 @@
 require 'minitest/autorun'
 require 'mocha/setup'
 require 'sequel'
-
-DB = Sequel.connect("postgres://admin:Zbx8L9W33E@localhost/gazou_postgres_test", :encoding => 'unicode')
-
 require 'database_cleaner'
 
+DB = Sequel.connect("postgres://localhost/storing_test", :encoding => 'unicode')
+
 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

data/spec/store_spec.rb

@@ -0,0 +1,161 @@
+require 'spec_helper'
+require 'storing/store'
+
+describe Storing::Store do
+	let(:table_name) { 'subscription' }
+	let(:primary_key) { :subscription_id }
+	let(:adaptor){ stub }
+	let(:store) { Storing::Store.new(adaptor) }
+
+	before do
+		Storing::Store.set_primary_key primary_key
+		Storing::Store.set_table_name table_name
+	end
+
+	after do
+		Storing::Store.set_primary_key nil
+		Storing::Store.set_table_name nil
+	end
+
+	describe "::set_primary_key" do
+		it "sets primary_key" do
+			Storing::Store.set_primary_key :user_id
+			Storing::Store.primary_key.must_equal :user_id
+		end
+	end
+
+	describe "::primary_key" do
+		describe "when primary_key is assigned" do
+			it "returns primary_key" do
+				Storing::Store.set_primary_key :user_id
+				Storing::Store.primary_key.must_equal :user_id
+			end
+		end
+
+		describe "when primary_key is unassigned" do
+			it "raises error" do
+				Storing::Store.set_primary_key nil
+				proc {Storing::Store.primary_key}.must_raise Storing::MissingPrimaryKey
+			end
+		end
+	end
+
+	describe "::set_table_name" do
+		it "sets primary_key" do
+			Storing::Store.set_table_name :users
+			Storing::Store.table_name.must_equal :users
+		end
+	end
+
+	describe "::table_name" do
+		describe "when table_name is assigned" do
+			it "returns table_name" do
+				Storing::Store.set_table_name :user_id
+				Storing::Store.table_name.must_equal :user_id
+			end
+		end
+
+		describe "when table_name is unassigned" do
+			it "raises error" do
+				Storing::Store.set_table_name nil
+				proc {Storing::Store.table_name}.must_raise Storing::MissingTableName
+			end
+		end
+	end
+
+	describe "#query" do
+		it "delegates to adaptor" do
+			arguments = stub
+			adaptor.expects(:query).with(arguments)
+			store.query(arguments)
+		end
+	end
+
+	describe "#select" do
+		it "delegates to adaptor with table name" do
+			conditions = stub
+			adaptor.expects(:select).with(table_name, conditions)
+			store.select(conditions)
+		end
+	end
+
+	describe "#insert" do
+		it "delegates to adaptor with table name" do
+			entity_hash = stub
+			adaptor.expects(:insert).with(table_name, entity_hash)
+			store.insert(entity_hash)
+		end
+	end
+
+	describe "#update" do
+		it "delegates to adaptor with table name" do
+			entity_hash = stub
+			params = stub
+			primary_key_hash = stub
+			entity = stub(:params => params, :primary_key_hash => primary_key_hash)
+			store.expects(:new_entity).with(entity_hash).returns(entity)
+			adaptor.expects(:update).with(table_name, params, primary_key_hash)
+			store.update(entity_hash)
+		end
+	end
+
+	describe "#delete" do
+		it "delegates to adaptor with table name" do
+			entity_hash = stub
+			primary_key_hash = stub
+			entity = stub(:primary_key_hash => primary_key_hash)
+			store.expects(:new_entity).with(entity_hash).returns(entity)
+			adaptor.expects(:delete).with(table_name, primary_key_hash)
+			store.delete(entity_hash)
+		end
+	end
+
+	describe "#transaction" do
+		it "delegates to adaptor" do
+			adaptor.expects(:transaction)
+			store.transaction
+		end
+	end
+
+	describe "#table_name" do
+		it "returns class table_name" do
+			Storing::Store.set_table_name 'my new table name'
+			store.table_name.must_equal 'my new table name'
+		end
+	end
+
+	describe "#primary_key" do
+		it "returns class primary_key" do
+			Storing::Store.set_primary_key 'my new primary key'
+			store.primary_key.must_equal 'my new primary key'
+		end
+	end
+end
+
+describe Storing::Store::Entity do
+	let(:data) {{:user_id => 123, :user_type => 'client', :age => 23, :first_name => 'John', :last_name => 'Doe'}}
+	let(:primary_key_column){[:user_id, :user_type]}
+	let(:entity_data) {Storing::Store::Entity.new(primary_key_column, data)}
+
+	describe "#primary_key_hash" do
+		describe "when primary_key is assigned" do
+			it "returns primary key in hash format" do
+				entity_data.primary_key_hash.must_equal({:user_id => 123, :user_type => 'client'})
+			end
+		end
+
+		describe "when primary key key is missing from data" do
+			let(:data) {{:user_id => 123, :age => 23, :first_name => 'John', :last_name => 'Doe'}}
+			
+			it "raises error" do
+				proc{ entity_data.primary_key_hash }.must_raise(Storing::MissingPrimaryKey)
+			end
+		end
+	end
+
+	describe "#params" do
+		it "returns data with primary key values removed" do
+			entity_data.params.must_equal(:age => 23, :first_name => 'John', :last_name => 'Doe')
+		end
+	end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: storing
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - Erik Lott
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-10-27 00:00:00.000000000 Z
+date: 2013-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -122,24 +122,25 @@ files:
 - README.md
 - Rakefile
 - lib/storing.rb
-- lib/storing/abstract_adaptor.rb
-- lib/storing/dataset.rb
-- lib/storing/entity_store.rb
+- lib/storing/abstract/abstract_adaptor.rb
+- lib/storing/abstract/abstract_deleter.rb
+- lib/storing/abstract/abstract_inserter.rb
+- lib/storing/abstract/abstract_mapper.rb
+- lib/storing/abstract/abstract_query.rb
+- lib/storing/abstract/abstract_store.rb
+- lib/storing/abstract/abstract_updater.rb
+- lib/storing/deleter.rb
 - lib/storing/exceptions.rb
-- lib/storing/postgres/abstract_queries/abstract_query.rb
-- lib/storing/postgres/abstract_queries/abstract_select_query.rb
+- lib/storing/inserter.rb
+- lib/storing/postgres/abstract_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/store.rb
+- lib/storing/updater.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/migrate/1382997183_create_person.rb
 - spec/postgres/adaptor_spec.rb
 - spec/spec_helper.rb
+- spec/store_spec.rb
 - storing.gemspec
 homepage: ''
 licenses:
@@ -166,10 +167,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/migrate/1382997183_create_person.rb
 - spec/postgres/adaptor_spec.rb
 - spec/spec_helper.rb
+- spec/store_spec.rb

data/lib/storing/dataset.rb

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

@@ -1,64 +0,0 @@
-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/postgres/abstract_queries/abstract_query.rb

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

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

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

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

@@ -1,17 +0,0 @@
-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/spec/dataset_spec.rb

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

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

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

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

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