mince_dynamo_db 1.3.1 → 2.0.0.pre.1

data/.travis.yml

@@ -0,0 +1,7 @@
+language: ruby
+rvm:
+  - "1.9.2"
+  - "1.9.3"
+
+# uncomment this line if your project needs to run something other than `rake`:
+#script: bundle exec rspec spec/units

data/README.md

@@ -7,7 +7,7 @@ Provides a very light weight interface for storing and retreiving information to
 The motivation behind this is so your application is not tightly tied to a specific database.  As your application grows you may need to upgrade to a different database or pull specific models to a different persistence strategy.
 
 [@github](https://github.com/coffeencoke/mince_dynamo_db)
-[@rubygems (not yet published)](#)
+[@rubygems](https://rubygems.org/gems/mince_dynamo_db)
 
 # How to use
 
@@ -15,13 +15,13 @@ view the [example mince rails app](https://github.com/coffeencoke/mince_rails_ex
 
 <pre>
 # Add a book to the books collection
-MinceDynamoDb::DataStore.add 'books', title: 'The World In Photographs', publisher: 'National Geographic'
+MinceDynamoDb::DataStore.instance.add 'books', title: 'The World In Photographs', publisher: 'National Geographic'
 
 # Retrieve all records from the books collection
-MinceDynamoDb::DataStore.find_all 'books'
+MinceDynamoDb::DataStore.instance.find_all 'books'
 
 # Replace a specific book
-MinceDynamoDb::DataStore.replace 'books', id: 1, title: 'A World In Photographs', publisher: 'National Geographic'
+MinceDynamoDb::DataStore.instance.replace 'books', id: 1, title: 'A World In Photographs', publisher: 'National Geographic'
 </pre>
 
 View the docs for MinceDynamoDb::DataStore for all methods available.

data/lib/dynamo_db.rb

@@ -0,0 +1,10 @@
+module Mince
+  module DynamoDb
+    require_relative 'dynamo_db/config'
+    require_relative 'dynamo_db/connection'
+    require_relative 'dynamo_db/data_sanitizer'
+    require_relative 'dynamo_db/data_store'
+    require_relative 'dynamo_db/interface'
+    require_relative 'dynamo_db/version'
+  end
+end

data/lib/dynamo_db/config.rb

@@ -0,0 +1,56 @@
+module Mince # :nodoc:
+  module DynamoDb # :nodoc:
+    require 'singleton'
+    require 'aws'
+
+    # = DynamoDb Config
+    #
+    # Config specifies the configuration settings
+    #
+    # @author Matt Simpson
+    class Config
+      include Singleton
+
+      # Returns the primary key identifier for records.  This is necessary because not all databases use the same
+      # primary key.
+      #
+      # @return [Symbol] the name of the primary key field.
+      def self.primary_key
+        instance.primary_key
+      end
+
+      # Returns the secret access key used for authenticating with Amazon's DynamoDB service
+      #
+      # Can either be set explicitely, or uses AWS.config by default
+      def self.secret_access_key
+        instance.secret_access_key
+      end
+
+      def self.access_key_id
+        instance.access_key_id
+      end
+
+      attr_reader :primary_key
+
+      def initialize
+        @primary_key = :id
+      end
+
+      def access_key_id
+        AWS.config.access_key_id
+      end
+
+      def access_key_id=(id)
+        AWS.config.access_key_id = id
+      end
+
+      def secret_access_key
+        AWS.config.secret_access_key
+      end
+
+      def secret_access_key=(key)
+        AWS.config.secret_access_key = key
+      end
+    end
+  end
+end

data/lib/dynamo_db/connection.rb

@@ -0,0 +1,21 @@
+module Mince
+  module DynamoDb
+    require 'singleton'
+    require_relative 'config'
+    require 'aws/dynamo_db'
+
+    class Connection
+      include Singleton
+
+      def self.connection
+        instance.connection
+      end
+
+      attr_accessor :connection
+
+      def connection
+        @connection ||= AWS::DynamoDB.new(access_key_id: Config.access_key_id, secret_access_key: Config.secret_access_key)
+      end
+    end
+  end
+end

data/lib/dynamo_db/data_sanitizer.rb

@@ -0,0 +1,13 @@
+module Mince
+  module DynamoDb
+    module DataSanitizer
+      def self.prepare_field_for_storage(field)
+        field.is_a?(Numeric) ? field : field.to_s
+      end
+
+      def self.prepare_hash_for_storage(hash)
+        hash.each{|key, value| hash[key] = prepare_field_for_storage(value) }
+      end
+    end
+  end
+end

data/lib/dynamo_db/data_store.rb

@@ -0,0 +1,44 @@
+module Mince
+  module DynamoDb # :nodoc:
+    require 'singleton'
+    require_relative 'connection'
+
+    class DataStore
+      include Singleton
+
+      # Returns the collection, or table, for a given collection name
+      # 
+      # The schema must be loaded before any queries are made against a collection
+      # There are a couple ways to do this, from digging in their documentation about
+      # this topic.  One is to have the schema loaded in memory, which is not recommended
+      # for production code, the other way is to call hash_key :) not sure why this works.
+      #
+      # @param [String] collection_name the name of the collection
+      # @return [AWS::DynamoDB::Table] the AWS::DynamoDB::Table for the given collection_name
+      def self.collection(collection_name)
+        collections[collection_name.to_s].tap do |c|
+          c.hash_key unless c.schema_loaded?
+        end
+      end
+
+      # Returns the database object which comes from MinceDynamoDb::Connection
+      def self.db
+        instance.db
+      end
+
+      def self.collections
+        db.tables
+      end
+
+      def self.items(collection_name)
+        collection(collection_name).items
+      end
+
+      attr_accessor :db
+
+      def db
+        @db ||= Connection.connection
+      end
+    end
+  end
+end

data/lib/dynamo_db/interface.rb

@@ -0,0 +1,232 @@
+module Mince
+  module DynamoDb # :nodoc:
+    require 'digest'
+    require 'active_support/hash_with_indifferent_access'
+    require_relative 'data_store'
+    require_relative 'data_sanitizer'
+    require_relative 'config'
+
+    module Interface
+      # Not yet implemented
+      def self.update_field_with_value(*args)
+        raise %(The method `MinceDynamoDb::DataStore.singleton.update_field_with_value` is not implemented, you should implement it for us!)
+      end
+
+      def self.delete_field(collection_name, field)
+        raise %(The method `MinceDynamoDb::DataStore.singleton.delete_field` is not implemented, you should implement it for us!)
+      end
+
+      def self.delete_collection(collection_name)
+        raise %(The method `MinceDynamoDb::DataStore.singleton.delete_collection` is not implemented, you should implement it for us!)
+      end
+
+      def self.increment_field_by_amount(collection_name, id, field_name, amount)
+        raise %(The method `MinceDynamoDb::DataStore.singleton.increment_field_by_amount` is not implemented, you should implement it for us!)
+      end
+
+
+
+      # Returns the primary key identifier for records.  This is necessary because not all databases use the same
+      # primary key.
+      #
+      # @return [String] the name of the primary key field.
+      def self.primary_key_identifier
+        Config.primary_key
+      end
+
+      # Generates a unique ID for a database record
+      #
+      # @note This is necessary because different databases use different types of primary key values. Thus, each mince
+      #       implementation must define how to generate a unique id.
+      #
+      # @param [#to_s] salt any object that responds to #to_s
+      # @return [String] A unique id based on the salt and the current time
+      def self.generate_unique_id(salt)
+        Digest::SHA256.hexdigest("#{Time.current.utc}#{salt}")[0..6]
+      end
+
+      # Inserts one record into a collection.
+      #
+      # @param [String] collection_name the name of the collection
+      # @param [Hash] hash a hash of data to be added to the collection
+      def self.add(collection_name, hash)
+        hash.delete_if{|k,v| v.nil? }
+        items(collection_name).create(sanitized_hash(hash))
+      end
+
+      # Replaces a record in the collection based on the primary key's value.  The hash must contain a key, defined
+      # by the +primary_key_identifier+ method, with a value.  If a record in the data store is found with that key and
+      # value, the entire record will be replaced with the given hash.
+      #
+      # @param [String] collection_name the name of the collection
+      # @param [Hash] hash a hash to replace the record in the collection with
+      def self.replace(collection_name, hash)
+        items(collection_name).put(sanitized_hash(hash))
+      end
+
+      # Gets all records that have the value for a given key.
+      #
+      # @param [String] collection_name the name of the collection
+      # @param [String] key the key, or field, to get a record for
+      # @param [*] value the value to get a record for
+      # @return [Array] an array of records that match the key and value
+      def self.get_all_for_key_with_value(collection_name, key, value)
+        get_by_params(collection_name, key => value)
+      end
+
+      # Gets the first record that has the value for a given key.
+      #
+      # @param [String] collection_name the name of the collection
+      # @param [String] key the key to find a record by
+      # @param [String] value the value to find a record by
+      # @return [Hash] a hash for the record found by the key and value in the collection
+      def self.get_for_key_with_value(collection_name, key, value)
+        get_all_for_key_with_value(collection_name, key.to_s, value).first
+      end
+
+      # Gets all records that have all of the keys and values in the given hash.
+      #
+      # @param [String] collection_name the name of the collection
+      # @param [Hash] hash a hash to get a record for
+      # @return [Array] an array of all records matching the given hash for the collection
+      def self.get_by_params(collection_name, hash)
+        hash = HashWithIndifferentAccess.new(hash)
+        array_to_hash(items(collection_name).where(hash).select)
+      end
+
+      # Gets all records for a collection
+      #
+      # @param [String] collection_name the name of the collection
+      # @return [Array] all records for the given collection name
+      def self.find_all(collection_name)
+        array_to_hash(items(collection_name).select)
+      end
+
+      # Gets a record matching a key and value
+      #
+      # @param [String] collection_name the name of the collection
+      # @param [String] key the key to find a record by
+      # @param [*] value a value the find a record by
+      # @return [Hash] a record that matches the given key and value
+      def self.find(collection_name, key, value)
+        get_for_key_with_value(collection_name, key, value)
+      end
+
+      # Pushes a value to a record's key that is an array
+      #
+      # @param [String] collection_name the name of the collection
+      # @param [String] identifying_key the field used to find the record
+      # @param [*] identifying_value the value used to find the record
+      # @param [String] array_key the field to push an array to
+      # @param [*] value_to_push the value to push to the array
+      def self.push_to_array(collection_name, identifying_key, identifying_value, array_key, value_to_push)
+        item = items(collection_name).where(identifying_key.to_s => identifying_value).first
+        item.attributes.add(array_key => [sanitized_field(value_to_push)])
+      end
+
+      # Removes a value from a record's key that is an array
+      #
+      # @param [String] collection_name the name of the collection
+      # @param [String] identifying_key the field used to find the record
+      # @param [*] identifying_value the value used to find the record
+      # @param [String] array_key the field to push an array from
+      # @param [*] value_to_remove the value to remove from the array
+      def self.remove_from_array(collection_name, identifying_key, identifying_value, array_key, value_to_remove)
+        item = items(collection_name).where(identifying_key.to_s => identifying_value).select.first      
+        item.attributes.delete(array_key => [value_to_remove])
+      end
+
+      # Returns all records where the given key contains any of the values provided
+      #
+      # @param [String] collection_name the name of the collection
+      # @param [String] key the key to find the record by
+      # @param [Array] values an array of values that the record could contain
+      # @return [Array] all records that contain any of the values given
+      def self.containing_any(collection_name, key, values)
+        array_to_hash items(collection_name).where(key.to_sym).in(values).select
+      end
+
+      # Returns all records where the given key contains the given value
+      #
+      # @param [String] collection_name the name of the collection
+      # @param [String] key the key to find records by
+      # @param [*] value the value to find a record by
+      # @return [Array] all records where the key contains the given value
+      def self.array_contains(collection_name, key, value)
+        array_to_hash items(collection_name).where(key.to_sym).contains(value).select
+      end
+
+      # Deletes a record that matches the given criteria from the data store.
+      def self.delete_by_params(collection_name, params)
+        item = items(collection_name).where(params).select.first
+        item.delete
+      end
+
+      # Clears the data store.
+      # Mainly used for rolling back the data store in tests.
+      def self.clear
+        db.tables.each do |t|
+          t.hash_key unless t.schema_loaded? # to load the schema
+          t.items.each do |i|
+            i.delete
+          end
+        end
+      end
+
+      def self.set_data(data)
+        clear
+
+        data.each do |key, records|
+          records.each do |record|
+            add key, record
+          end
+        end
+      end
+
+      # Returns the collection, or table, for a given collection name
+      # 
+      # The schema must be loaded before any queries are made against a collection
+      # There are a couple ways to do this, from digging in their documentation about
+      # this topic.  One is to have the schema loaded in memory, which is not recommended
+      # for production code, the other way is to call hash_key :) not sure why this works.
+      #
+      # @param [String] collection_name the name of the collection
+      # @return [AWS::DynamoDB::Table] the AWS::DynamoDB::Table for the given collection_name
+      def self.collection(collection_name)
+        DataStore.collection(collection_name)
+      end
+
+      def self.sanitized_field(field)
+        DataSanitizer.prepare_field_for_storage(field)
+      end
+
+      def self.sanitized_hash(hash)
+        DataSanitizer.prepare_hash_for_storage(hash)
+      end
+
+      # Takes a DynamoDB item and returns the attributes of that item as a hash
+      def self.to_hash(item)
+        item.attributes if item
+      end
+
+      # Takes an array of DynamoDB items and returns the attributes of each item as a hash.
+      # calls 
+      def self.array_to_hash(array)
+        array.map{|a| to_hash(a) }
+      end
+
+      # Returns the database object which comes from MinceDynamoDb::Connection
+      def self.db
+        DataStore.db
+      end
+
+      def self.collections
+        DataStore.collections
+      end
+
+      def self.items(collection_name)
+        DataStore.items(collection_name)
+      end
+    end
+  end
+end

data/lib/dynamo_db/version.rb

@@ -0,0 +1,22 @@
+module Mince
+  module DynamoDb
+    module Version
+      def self.major
+        2
+      end
+
+      def self.minor
+        0
+      end
+
+      def self.patch
+        "0.pre.1"
+      end
+    end
+
+    def self.version
+      [Version.major, Version.minor, Version.patch].join(".")
+    end
+  end
+end
+

data/mince_dynamo_db.gemspec

@@ -1,10 +1,10 @@
 # -*- encoding: utf-8 -*-
 $:.push File.expand_path("../lib", __FILE__)
-require "mince_dynamo_db/version"
+require "dynamo_db/version"
 
 Gem::Specification.new do |s|
   s.name        = "mince_dynamo_db"
-  s.version     = MinceDynamoDb::VERSION
+  s.version     = Mince::DynamoDb.version
   s.authors     = ["Matt Simpson"]
   s.email       = ["matt@railsgrammer.com"]
   s.homepage    = "https://github.com/coffeencoke/mince_dynamo_db"
@@ -21,8 +21,11 @@ Gem::Specification.new do |s|
   s.add_dependency 'aws-sdk', "~> 1.3.7"
   s.add_dependency 'activesupport', "~> 3.0"
 
+  s.add_development_dependency('rake', '~> 0.9')
   s.add_development_dependency "rspec", "~> 2.8.0"
   s.add_development_dependency "guard-rspec", "~> 0.6.0"
   s.add_development_dependency "yard", "~> 0.7.5"
   s.add_development_dependency "redcarpet", "~> 2.1.1"
+  s.add_development_dependency "fake_dynamo"
+  s.add_development_dependency "mince", "~> 2.0.0.pre.2"
 end

data/spec/integration/mince_interface_spec.rb

@@ -0,0 +1,18 @@
+require_relative '../../lib/dynamo_db'
+require 'mince/shared_examples/interface_example'
+
+describe 'Mince Interface with DynamoDb' do
+  pending do
+  before do
+    AWS.config(
+      :use_ssl => false,
+      :dynamo_db_endpoint => 'localhost',
+      :access_key_id => "xxx",
+      :secret_access_key => "xxx"
+    )
+    Mince::Config.interface = Mince::DynamoDb::Interface
+  end
+
+  it_behaves_like 'a mince interface'
+end
+end

data/spec/units/config_spec.rb

@@ -0,0 +1,19 @@
+require_relative '../../lib/dynamo_db/config'
+
+describe Mince::DynamoDb::Config do
+  let(:secret_access_key) { mock }
+  let(:access_key_id) { mock }
+
+  before do
+    AWS.config(access_key_id: access_key_id, secret_access_key: secret_access_key)
+  end
+
+  it 'uses "id" as the primary key for the database' do
+    described_class.primary_key.should == :id
+  end
+
+  it "has the credentials for using Amazon's Dynamo DB service" do
+    described_class.secret_access_key.should == secret_access_key
+    described_class.access_key_id.should == access_key_id
+  end
+end

data/spec/{lib → units}/connection_spec.rb

@@ -1,6 +1,6 @@
-require_relative '../../lib/mince_dynamo_db/connection'
+require_relative '../../lib/dynamo_db/connection'
 
-describe MinceDynamoDb::Connection do
+describe Mince::DynamoDb::Connection do
   subject { described_class.instance }
 
   let(:connection) { mock 'an amazon dynamo db object' }
@@ -9,7 +9,7 @@ describe MinceDynamoDb::Connection do
   let(:aws_config) { mock 'aws config object', secret_access_key: secret_access_key, access_key_id: access_key_id }
 
   before do
-    AWS.stub(config: aws_config)
+    Mince::DynamoDb::Config.stub(access_key_id: access_key_id, secret_access_key: secret_access_key)
   end
 
   it 'has a dynamo db connection' do
@@ -17,4 +17,4 @@ describe MinceDynamoDb::Connection do
 
     subject.connection.should == connection
   end
-end
+end

data/spec/{lib → units}/data_sanitizer_spec.rb

@@ -1,8 +1,8 @@
-require_relative '../../lib/mince_dynamo_db/data_sanitizer'
+require_relative '../../lib/dynamo_db/data_sanitizer'
 
 require 'date'
 
-describe MinceDynamoDb::DataSanitizer do
+describe Mince::DynamoDb::DataSanitizer do
   it 'converts a Time object to a string' do
     value = Time.now
 

data/spec/units/data_store_spec.rb

@@ -0,0 +1,55 @@
+require_relative '../../lib/dynamo_db/data_store'
+
+describe Mince::DynamoDb::DataStore do
+  let(:db) { mock 'db connection', tables: collections }
+  let(:collections) { { collection_name => collection }  }
+  let(:collection) { mock 'some collection', items: items, schema_loaded?: true }
+  let(:collection_name) { 'some_collection_name'}
+  let(:items) { mock 'items' }
+
+  before do
+    described_class.instance.db = db # do this each time because it's a singleton
+  end
+
+  describe 'when getting a collection' do
+    context 'when the schema has not been loaded' do
+      before do
+        collection.stub(schema_loaded?: false, hash_key: nil)
+      end
+
+      it 'loads the schema' do
+        collection.should_receive(:hash_key)
+
+        described_class.collection(collection_name)
+      end
+
+      it 'returns the collection' do
+        described_class.collection(collection_name).should == collection
+      end
+    end
+
+    context 'when the schema has been loaded' do
+      it 'does not load the schema' do
+        collection.should_not_receive(:hash_key)
+
+        described_class.collection(collection_name)
+      end
+
+      it 'returns the collection' do
+        described_class.collection(collection_name).should == collection
+      end
+    end
+  end
+
+  it 'can get the items for a given collection' do
+    described_class.items(collection_name).should == items
+  end
+
+  it 'can return the db' do
+    described_class.db.should == db
+  end
+
+  it 'can get all collections' do
+    described_class.collections.should == collections
+  end
+end

data/spec/{lib/data_store_spec.rb → units/interface_spec.rb}

@@ -1,11 +1,10 @@
-require_relative '../../lib/mince_dynamo_db/data_store'
-
-describe MinceDynamoDb::DataStore do
-  subject { described_class.instance }
+require_relative '../../lib/dynamo_db/interface'
 
+describe Mince::DynamoDb::Interface do
   let(:db) { mock 'dynamo db connection', tables: { collection_name => collection } }
   let(:mince_dynamo_db_connection) { mock 'mince dynamo db connection', connection: db }
   let(:collection) { mock 'some collection', items: items, schema_loaded?: true }
+  let(:collections) { mock }
   let(:collection_name) { 'some_collection_name'}
   let(:primary_key) { mock 'primary key'}
   let(:mock_id) { mock 'id' }
@@ -18,16 +17,10 @@ describe MinceDynamoDb::DataStore do
   let(:items) { mock 'items' }
 
   before do
-    MinceDynamoDb::DataSanitizer.stub(:prepare_hash_for_storage).with(data).and_return(sanitized_data)
-    MinceDynamoDb::Connection.stub(:instance => mince_dynamo_db_connection)
-  end
-
-  it 'uses the correct collection' do
-    subject.collection(collection_name).should == collection
-  end
-
-  it 'has a primary key identifier' do
-    described_class.primary_key_identifier.should == 'id'
+    Mince::DynamoDb::DataStore.stub(:items).with(collection_name).and_return(items)
+    Mince::DynamoDb::DataStore.stub(:collection).with(collection_name).and_return(collection)
+    Mince::DynamoDb::DataStore.stub(collections: collections, db: db)
+    Mince::DynamoDb::DataSanitizer.stub(:prepare_hash_for_storage).with(data).and_return(sanitized_data)
   end
 
   describe "Generating a primary key" do
@@ -50,21 +43,21 @@ describe MinceDynamoDb::DataStore do
   it 'can write to the collection' do
     items.should_receive(:create).with(sanitized_data).and_return(return_data)
 
-    subject.add(collection_name, data).should == return_data
+    described_class.add(collection_name, data).should == return_data
   end
 
   it 'can read from the collection' do
     item_attributes = mock 'attributes for an item'
     item = mock 'item', attributes: item_attributes
-    collection.stub(items: [item])
+    items.should_receive(:select).and_return([item])
 
-    subject.find_all(collection_name).should == [item_attributes]
+    described_class.find_all(collection_name).should == [item_attributes]
   end
 
   it 'can replace a record' do
     items.should_receive(:put).with(sanitized_data)
 
-    subject.replace(collection_name, data)
+    described_class.replace(collection_name, data)
   end
 
   it 'can get one document' do
@@ -73,7 +66,7 @@ describe MinceDynamoDb::DataStore do
 
     items.should_receive(:where).with(field => value).and_return([return_data])
     
-    subject.find(collection_name, field, value).should == attributes
+    described_class.find(collection_name, field, value).should == attributes
   end
 
   it 'can delete a record that matches a criteria' do
@@ -81,7 +74,7 @@ describe MinceDynamoDb::DataStore do
     items.should_receive(:where).with(params).and_return([return_data])
     return_data.should_receive(:delete)
     
-    subject.delete_by_params(collection_name, params)
+    described_class.delete_by_params(collection_name, params)
   end
 
   it 'can clear the data store' do
@@ -96,19 +89,19 @@ describe MinceDynamoDb::DataStore do
     item.should_receive(:delete)
     item2.should_receive(:delete)
     
-    subject.clear
+    described_class.clear
   end
 
   it 'can get all records of a specific key value' do
     items.should_receive(:where).with("key" => "value").and_return([return_data])
 
-    subject.get_all_for_key_with_value(collection_name, "key", "value").should == [attributes]
+    described_class.get_all_for_key_with_value(collection_name, "key", "value").should == [attributes]
   end
 
   it 'can get a record of a specific key value' do
     items.should_receive(:where).with({"key" => "value"}).and_return([return_data])
 
-    subject.get_for_key_with_value(collection_name, "key", "value").should == attributes
+    described_class.get_for_key_with_value(collection_name, "key", "value").should == attributes
   end
 
   it 'can get all records where a value includes any of a set of values' do
@@ -116,7 +109,7 @@ describe MinceDynamoDb::DataStore do
     items.should_receive(:where).with(:key1).and_return(filter)
     filter.should_receive(:in).with([1,2,4]).and_return([return_data])
 
-    subject.containing_any(collection_name, "key1", [1,2,4]).should == [attributes]
+    described_class.containing_any(collection_name, "key1", [1,2,4]).should == [attributes]
   end
 
   it 'can get all records where the array includes a value' do
@@ -124,23 +117,23 @@ describe MinceDynamoDb::DataStore do
     items.should_receive(:where).with(:key).and_return(filter)
     filter.should_receive(:contains).with('value').and_return([return_data])
 
-    subject.array_contains(collection_name, "key", "value").should == [attributes]
+    described_class.array_contains(collection_name, "key", "value").should == [attributes]
   end
 
   it 'can push a value to an array for a specific record' do
     value_to_push = mock 'value to push to the record'
     sanitized_value_to_push = mock 'sanitized value to push to the record'
-    MinceDynamoDb::DataSanitizer.stub(:prepare_field_for_storage).with(value_to_push).and_return(sanitized_value_to_push)
+    Mince::DynamoDb::DataSanitizer.stub(:prepare_field_for_storage).with(value_to_push).and_return(sanitized_value_to_push)
     items.should_receive(:where).with("key" => "value").and_return([return_data])
     attributes.should_receive(:add).with(:array_key => [sanitized_value_to_push])
 
-    subject.push_to_array(collection_name, :key, "value", :array_key, value_to_push)
+    described_class.push_to_array(collection_name, :key, "value", :array_key, value_to_push)
   end
 
   it 'can remove a value from an array for a specific record' do
     items.should_receive(:where).with("key" => "value").and_return([return_data])
     attributes.should_receive(:delete).with(:array_key => ["value_to_remove"])
 
-    subject.remove_from_array(collection_name, :key, "value", :array_key, "value_to_remove")
+    described_class.remove_from_array(collection_name, :key, "value", :array_key, "value_to_remove")
   end
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: mince_dynamo_db
 version: !ruby/object:Gem::Version
-  version: 1.3.1
-  prerelease: 
+  version: 2.0.0.pre.1
+  prerelease: 6
 platform: ruby
 authors:
 - Matt Simpson
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-07 00:00:00.000000000 Z
+date: 2012-11-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -43,6 +43,22 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
@@ -107,6 +123,38 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 2.1.1
+- !ruby/object:Gem::Dependency
+  name: fake_dynamo
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mince
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0.pre.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.0.0.pre.2
 description: Lightweight ORM for Amazon's DynamoDB with Ruby Apps
 email:
 - matt@railsgrammer.com
@@ -117,21 +165,25 @@ files:
 - .gitignore
 - .rspec
 - .rvmrc
+- .travis.yml
 - Gemfile
 - Guardfile
 - README.md
 - Rakefile
-- lib/mince_dynamo_db.rb
-- lib/mince_dynamo_db/connection.rb
-- lib/mince_dynamo_db/data_sanitizer.rb
-- lib/mince_dynamo_db/data_store.rb
-- lib/mince_dynamo_db/version.rb
+- lib/dynamo_db.rb
+- lib/dynamo_db/config.rb
+- lib/dynamo_db/connection.rb
+- lib/dynamo_db/data_sanitizer.rb
+- lib/dynamo_db/data_store.rb
+- lib/dynamo_db/interface.rb
+- lib/dynamo_db/version.rb
 - mince_dynamo_db.gemspec
-- spec/integration/persisting_to_dynamodb_test.rb
-- spec/lib/connection_spec.rb
-- spec/lib/data_sanitizer_spec.rb
-- spec/lib/data_store_spec.rb
-- spec/support/aws_example.yml
+- spec/integration/mince_interface_spec.rb
+- spec/units/config_spec.rb
+- spec/units/connection_spec.rb
+- spec/units/data_sanitizer_spec.rb
+- spec/units/data_store_spec.rb
+- spec/units/interface_spec.rb
 homepage: https://github.com/coffeencoke/mince_dynamo_db
 licenses: []
 post_install_message: 
@@ -144,12 +196,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   - - ! '>='
     - !ruby/object:Gem::Version
       version: '0'
+      segments:
+      - 0
+      hash: -4539691897538722192
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: mince_dynamo_db
 rubygems_version: 1.8.24
@@ -157,9 +212,10 @@ signing_key:
 specification_version: 3
 summary: Lightweight ORM for Amazon's DynamoDB with Ruby Apps
 test_files:
-- spec/integration/persisting_to_dynamodb_test.rb
-- spec/lib/connection_spec.rb
-- spec/lib/data_sanitizer_spec.rb
-- spec/lib/data_store_spec.rb
-- spec/support/aws_example.yml
+- spec/integration/mince_interface_spec.rb
+- spec/units/config_spec.rb
+- spec/units/connection_spec.rb
+- spec/units/data_sanitizer_spec.rb
+- spec/units/data_store_spec.rb
+- spec/units/interface_spec.rb
 has_rdoc: 

data/lib/mince_dynamo_db.rb

@@ -1,3 +0,0 @@
-require 'mince_dynamo_db/connection'
-require 'mince_dynamo_db/data_store'
-require "mince_dynamo_db/version"

data/lib/mince_dynamo_db/connection.rb

@@ -1,24 +0,0 @@
-require 'aws'
-require 'singleton'
-
-module MinceDynamoDb
-  class Connection
-    include Singleton
-
-    attr_reader :connection
-
-    def initialize
-      @connection = AWS::DynamoDB.new access_key_id: access_key_id, secret_access_key: secret_access_key
-    end
-
-    private
-
-    def access_key_id
-      AWS.config.access_key_id
-    end
-
-    def secret_access_key
-      AWS.config.secret_access_key
-    end
-  end
-end

data/lib/mince_dynamo_db/data_sanitizer.rb

@@ -1,11 +0,0 @@
-module MinceDynamoDb
-  module DataSanitizer
-    def self.prepare_field_for_storage(field)
-      field.is_a?(Numeric) ? field : field.to_s
-    end
-
-    def self.prepare_hash_for_storage(hash)
-      hash.each{|key, value| hash[key] = prepare_field_for_storage(value) }
-    end
-  end
-end

data/lib/mince_dynamo_db/data_store.rb

@@ -1,269 +0,0 @@
-require 'singleton'
-require 'digest'
-require 'active_support/hash_with_indifferent_access'
-
-require_relative 'connection'
-require_relative 'data_sanitizer'
-
-module MinceDynamoDb # :nodoc:
-  # = Mince DynamoDb Data Store
-  #
-  # Mince DynamoDb Data Store stores and retrieves data from a DynamoDB table. It supports the same methods
-  # as the following libraries:
-  #
-  # Mince::
-  #   A lightweight ruby library to store and retrieve data from MongoDB (https://github.com/asynchrony/mince)
-  # HashyDb:: 
-  #   A lightweight ruby library to store and retrieve data from a hash in-memory. (https://github.com/asynchrony/hashy_db)
-  #
-  # Using this library offers more extensibility and growth for your application.  If at any point in time
-  # you want to support a different database for all, or even one, of your classes, you only need to implement
-  # the few methods defined in this class.
-  #
-  # You can use the {https://github.com/asynchrony/mince_data_model Mince Data Model} as a helper library to 
-  # provide support in writing an application using these data persistance libraries.
-  # 
-  # To use the Data Store, define your DynamoDB access_key_id and secret_access_key.  If you are using rails
-  # you can do this by creating a file at config/aws.yml with the following contents:
-  #
-  #   development:
-  #     access_key_id: REPLACE_WITH_ACCESS_KEY_ID
-  #     secret_access_key: REPLACE_WITH_SECRET_ACCESS_KEY
-  #    
-  # Otherwise, you can set the configurations like so:
-  #
-  #   require 'aws'
-  #
-  #   AWS.config.access_key_id = REPLACE_WITH_ACCESS_KEY_ID
-  #   AWS.config.secret_access_key = REPLACE_WITH_SECRET_ACCESS_KEY
-  #
-  # View the aws documentation for more details at http://docs.amazonwebservices.com/AWSRubySDK/latest/frames.html
-  #
-  # Once you have the settings configured, you can start storing and retrieving data:
-  #
-  #   data_store = MinceDynamoDb::DataStore.instance
-  #   data_store.add 'fruits', id: '1', name: 'Shnawzberry', color: 'redish', quantity: '20'
-  #   data_store.get_for_key_with_value 'fruits', :color, 'redish'
-  #
-  # @author Matt Simpson
-  class DataStore
-    include Singleton
-
-
-
-    # Not yet implemented
-    def update_field_with_value(*args)
-      raise %(The method `MinceDynamoDb::DataStore.singleton.update_field_with_value` is not implemented, you should implement it for us!)
-    end
-
-    def delete_field(collection_name, field)
-      raise %(The method `MinceDynamoDb::DataStore.singleton.delete_field` is not implemented, you should implement it for us!)
-    end
-
-    def delete_collection(collection_name)
-      raise %(The method `MinceDynamoDb::DataStore.singleton.delete_collection` is not implemented, you should implement it for us!)
-    end
-
-    def increment_field_by_amount(collection_name, id, field_name, amount)
-      raise %(The method `MinceDynamoDb::DataStore.singleton.increment_field_by_amount` is not implemented, you should implement it for us!)
-    end
-
-
-
-    # Returns the primary key identifier for records.  This is necessary because not all databases use the same
-    # primary key.
-    #
-    # @return [String] the name of the primary key field.
-    def self.primary_key_identifier
-      'id'
-    end
-
-    # Generates a unique ID for a database record
-    #
-    # @note This is necessary because different databases use different types of primary key values. Thus, each mince
-    #       implementation must define how to generate a unique id.
-    #
-    # @param [#to_s] salt any object that responds to #to_s
-    # @return [String] A unique id based on the salt and the current time
-    def self.generate_unique_id(salt)
-      Digest::SHA256.hexdigest("#{Time.current.utc}#{salt}")[0..6]
-    end
-
-    # Inserts one record into a collection.
-    #
-    # @param [String] collection_name the name of the collection
-    # @param [Hash] hash a hash of data to be added to the collection
-    def add(collection_name, hash)
-      hash.delete_if{|k,v| v.nil? }
-      items(collection_name).create(sanitized_hash(hash))
-    end
-
-    # Replaces a record in the collection based on the primary key's value.  The hash must contain a key, defined
-    # by the +primary_key_identifier+ method, with a value.  If a record in the data store is found with that key and
-    # value, the entire record will be replaced with the given hash.
-    #
-    # @param [String] collection_name the name of the collection
-    # @param [Hash] hash a hash to replace the record in the collection with
-    def replace(collection_name, hash)
-      items(collection_name).put(sanitized_hash(hash))
-    end
-
-    # Gets all records that have the value for a given key.
-    #
-    # @param [String] collection_name the name of the collection
-    # @param [String] key the key, or field, to get a record for
-    # @param [*] value the value to get a record for
-    # @return [Array] an array of records that match the key and value
-    def get_all_for_key_with_value(collection_name, key, value)
-      get_by_params(collection_name, key => value)
-    end
-
-    # Gets the first record that has the value for a given key.
-    #
-    # @param [String] collection_name the name of the collection
-    # @param [String] key the key to find a record by
-    # @param [String] value the value to find a record by
-    # @return [Hash] a hash for the record found by the key and value in the collection
-    def get_for_key_with_value(collection_name, key, value)
-      get_all_for_key_with_value(collection_name, key.to_s, value).first
-    end
-
-    # Gets all records that have all of the keys and values in the given hash.
-    #
-    # @param [String] collection_name the name of the collection
-    # @param [Hash] hash a hash to get a record for
-    # @return [Array] an array of all records matching the given hash for the collection
-    def get_by_params(collection_name, hash)
-      hash = HashWithIndifferentAccess.new(hash)
-      array_to_hash(items(collection_name).where(hash).select)
-    end
-
-    # Gets all records for a collection
-    #
-    # @param [String] collection_name the name of the collection
-    # @return [Array] all records for the given collection name
-    def find_all(collection_name)
-      array_to_hash(items(collection_name).select)
-    end
-
-    # Gets a record matching a key and value
-    #
-    # @param [String] collection_name the name of the collection
-    # @param [String] key the key to find a record by
-    # @param [*] value a value the find a record by
-    # @return [Hash] a record that matches the given key and value
-    def find(collection_name, key, value)
-      get_for_key_with_value(collection_name, key, value)
-    end
-
-    # Pushes a value to a record's key that is an array
-    #
-    # @param [String] collection_name the name of the collection
-    # @param [String] identifying_key the field used to find the record
-    # @param [*] identifying_value the value used to find the record
-    # @param [String] array_key the field to push an array to
-    # @param [*] value_to_push the value to push to the array
-    def push_to_array(collection_name, identifying_key, identifying_value, array_key, value_to_push)
-      item = items(collection_name).where(identifying_key.to_s => identifying_value).first
-      item.attributes.add(array_key => [sanitized_field(value_to_push)])
-    end
-
-    # Removes a value from a record's key that is an array
-    #
-    # @param [String] collection_name the name of the collection
-    # @param [String] identifying_key the field used to find the record
-    # @param [*] identifying_value the value used to find the record
-    # @param [String] array_key the field to push an array from
-    # @param [*] value_to_remove the value to remove from the array
-    def remove_from_array(collection_name, identifying_key, identifying_value, array_key, value_to_remove)
-      item = items(collection_name).where(identifying_key.to_s => identifying_value).select.first      
-      item.attributes.delete(array_key => [value_to_remove])
-    end
-
-    # Returns all records where the given key contains any of the values provided
-    #
-    # @param [String] collection_name the name of the collection
-    # @param [String] key the key to find the record by
-    # @param [Array] values an array of values that the record could contain
-    # @return [Array] all records that contain any of the values given
-    def containing_any(collection_name, key, values)
-      array_to_hash items(collection_name).where(key.to_sym).in(values).select
-    end
-
-    # Returns all records where the given key contains the given value
-    #
-    # @param [String] collection_name the name of the collection
-    # @param [String] key the key to find records by
-    # @param [*] value the value to find a record by
-    # @return [Array] all records where the key contains the given value
-    def array_contains(collection_name, key, value)
-      array_to_hash items(collection_name).where(key.to_sym).contains(value).select
-    end
-
-    # Deletes a record that matches the given criteria from the data store.
-    def delete_by_params(collection_name, params)
-      item = items(collection_name).where(params).select.first
-      item.delete
-    end
-
-    # Clears the data store.
-    # Mainly used for rolling back the data store in tests.
-    def clear
-      db.tables.each do |t|
-        t.hash_key unless t.schema_loaded? # to load the schema
-        t.items.each do |i|
-          i.delete
-        end
-      end
-    end
-
-    # Returns the collection, or table, for a given collection name
-    # 
-    # The schema must be loaded before any queries are made against a collection
-    # There are a couple ways to do this, from digging in their documentation about
-    # this topic.  One is to have the schema loaded in memory, which is not recommended
-    # for production code, the other way is to call hash_key :) not sure why this works.
-    #
-    # @param [String] collection_name the name of the collection
-    # @return [AWS::DynamoDB::Table] the AWS::DynamoDB::Table for the given collection_name
-    def collection(collection_name)
-      db.tables[collection_name.to_s].tap do |c|
-        c.hash_key unless c.schema_loaded?
-      end
-    end
-
-    private
-
-    def sanitized_field(field)
-      DataSanitizer.prepare_field_for_storage(field)
-    end
-
-    def sanitized_hash(hash)
-      DataSanitizer.prepare_hash_for_storage(hash)
-    end
-
-    # Takes a DynamoDB item and returns the attributes of that item as a hash
-    def to_hash(item)
-      item.attributes if item
-    end
-
-    # Takes an array of DynamoDB items and returns the attributes of each item as a hash.
-    # calls 
-    def array_to_hash(array)
-      array.map{|a| to_hash(a) }
-    end
-
-    # Returns the database object which comes from MinceDynamoDb::Connection
-    def db
-      MinceDynamoDb::Connection.instance.connection
-    end
-
-    def collections
-      db.tables
-    end
-
-    def items(collection_name)
-      collection(collection_name).items
-    end
-  end
-end

data/lib/mince_dynamo_db/version.rb

@@ -1,3 +0,0 @@
-module MinceDynamoDb
-  VERSION = "1.3.1"
-end

data/spec/integration/persisting_to_dynamodb_test.rb

@@ -1,18 +0,0 @@
-require_relative '../../lib/mince_dynamo_db'
-require 'aws'
-
-describe 'Testing mince_dynamo_db/data_store while actually hitting dynamo db:' do
-  AWS.config.access_key_id = 'enter_access_key_id_here'
-  AWS.config.secret_access_key = 'enter_secret_access_key_here'
-  
-  # Ensure clear db before tests
-  before(:all) do
-    MinceDynamoeDb::DataStore.instance.clear
-  end
-
-  # Ensure clear db after tests
-  after(:all) do
-    MinceDynamoeDb::DataStore.instance.clear
-  end
-end
-