mince_dynamo_db 2.0.0.pre.1 → 2.0.0.pre.2

data/lib/mince_dynamo_db.rb

@@ -0,0 +1,8 @@
+module MinceDynamoDb
+  require_relative 'mince_dynamo_db/config'
+  require_relative 'mince_dynamo_db/connection'
+  require_relative 'mince_dynamo_db/data_sanitizer'
+  require_relative 'mince_dynamo_db/data_store'
+  require_relative 'mince_dynamo_db/interface'
+  require_relative 'mince_dynamo_db/version'
+end

data/lib/mince_dynamo_db/config.rb

@@ -0,0 +1,62 @@
+module MinceDynamoDb # :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
+
+    def self.secret_access_key=(val)
+      instance.secret_access_key = val
+    end
+
+    def self.access_key_id=(val)
+      instance.access_key_id = val
+    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

data/lib/mince_dynamo_db/connection.rb

@@ -0,0 +1,19 @@
+module MinceDynamoDb
+  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

data/lib/mince_dynamo_db/data_sanitizer.rb

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

@@ -0,0 +1,42 @@
+module MinceDynamoDb # :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

data/lib/mince_dynamo_db/interface.rb

@@ -0,0 +1,230 @@
+module MinceDynamoDb # :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

data/lib/mince_dynamo_db/version.rb

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

data/spec/integration/mince_interface_spec.rb

@@ -1,16 +1,16 @@
-require_relative '../../lib/dynamo_db'
+require_relative '../../lib/mince_dynamo_db'
 require 'mince/shared_examples/interface_example'
 
 describe 'Mince Interface with DynamoDb' do
-  pending do
+  pending 'need to write a setup and teardown to create the db and tables needed' do
   before do
     AWS.config(
       :use_ssl => false,
-      :dynamo_db_endpoint => 'localhost',
+      :mince_dynamo_db_endpoint => 'localhost',
       :access_key_id => "xxx",
       :secret_access_key => "xxx"
     )
-    Mince::Config.interface = Mince::DynamoDb::Interface
+    Mince::Config.interface = MinceDynamoDb::Interface
   end
 
   it_behaves_like 'a mince interface'

data/spec/units/config_spec.rb

@@ -1,6 +1,6 @@
-require_relative '../../lib/dynamo_db/config'
+require_relative '../../lib/mince_dynamo_db/config'
 
-describe Mince::DynamoDb::Config do
+describe MinceDynamoDb::Config do
   let(:secret_access_key) { mock }
   let(:access_key_id) { mock }
 

data/spec/units/connection_spec.rb

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

data/spec/units/data_sanitizer_spec.rb

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

data/spec/units/data_store_spec.rb

@@ -1,6 +1,6 @@
-require_relative '../../lib/dynamo_db/data_store'
+require_relative '../../lib/mince_dynamo_db/data_store'
 
-describe Mince::DynamoDb::DataStore do
+describe MinceDynamoDb::DataStore do
   let(:db) { mock 'db connection', tables: collections }
   let(:collections) { { collection_name => collection }  }
   let(:collection) { mock 'some collection', items: items, schema_loaded?: true }

data/spec/units/interface_spec.rb

@@ -1,6 +1,6 @@
-require_relative '../../lib/dynamo_db/interface'
+require_relative '../../lib/mince_dynamo_db/interface'
 
-describe Mince::DynamoDb::Interface do
+describe MinceDynamoDb::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 }
@@ -17,10 +17,10 @@ describe Mince::DynamoDb::Interface do
   let(:items) { mock 'items' }
 
   before do
-    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)
+    MinceDynamoDb::DataStore.stub(:items).with(collection_name).and_return(items)
+    MinceDynamoDb::DataStore.stub(:collection).with(collection_name).and_return(collection)
+    MinceDynamoDb::DataStore.stub(collections: collections, db: db)
+    MinceDynamoDb::DataSanitizer.stub(:prepare_hash_for_storage).with(data).and_return(sanitized_data)
   end
 
   describe "Generating a primary key" do
@@ -123,7 +123,7 @@ describe Mince::DynamoDb::Interface do
   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'
-    Mince::DynamoDb::DataSanitizer.stub(:prepare_field_for_storage).with(value_to_push).and_return(sanitized_value_to_push)
+    MinceDynamoDb::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])
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mince_dynamo_db
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.1
+  version: 2.0.0.pre.2
   prerelease: 6
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-11-01 00:00:00.000000000 Z
+date: 2012-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk
@@ -123,22 +123,6 @@ 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
@@ -162,22 +146,13 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .rvmrc
-- .travis.yml
-- Gemfile
-- Guardfile
-- README.md
-- Rakefile
-- 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
+- lib/mince_dynamo_db.rb
+- lib/mince_dynamo_db/config.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/interface.rb
+- lib/mince_dynamo_db/version.rb
 - spec/integration/mince_interface_spec.rb
 - spec/units/config_spec.rb
 - spec/units/connection_spec.rb
@@ -198,7 +173,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4539691897538722192
+      hash: -471291814637283281
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:

data/.gitignore

@@ -1,6 +0,0 @@
-*.gem
-.yardoc
-doc
-.bundle
-Gemfile.lock
-pkg/*

data/.rspec

@@ -1 +0,0 @@
---colour

data/.rvmrc

@@ -1 +0,0 @@
-rvm use 1.9.3

data/.travis.yml

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

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

data/Guardfile

@@ -1,13 +0,0 @@
-# A sample Guardfile
-# More info at https://github.com/guard/guard#readme
-#
-
-guard 'rspec', :version => 2 do
-  watch(%r{^spec/lib/.+_spec\.rb$})
-  watch(%r{^lib/.+\.rb$})
-  watch(%r{^lib/mince_dynamo_db/.+\.rb$})
-  watch(%r{^lib/(.+)\.rb})                            { |m| "spec/lib/#{m[1]}_spec.rb" }
-  watch(%r{^spec/support/(.+)\.rb$})                  { "spec" }
-  watch(%r{^spec/support/shared_examples/(.+)\.rb$})  { "spec" }
-end
-

data/README.md

@@ -1,59 +0,0 @@
-# What is mince dynamo db?
-
-Light weight ORM to persist data to an Amazon DynamoDB database.
-
-Provides a very light weight interface for storing and retreiving information to DynamoDB.
-
-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](https://rubygems.org/gems/mince_dynamo_db)
-
-# How to use
-
-view the [example mince rails app](https://github.com/coffeencoke/mince_rails_example) to see how to use this.
-
-<pre>
-# Add a book to the books collection
-MinceDynamoDb::DataStore.instance.add 'books', title: 'The World In Photographs', publisher: 'National Geographic'
-
-# Retrieve all records from the books collection
-MinceDynamoDb::DataStore.instance.find_all 'books'
-
-# Replace a specific book
-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.
-
-Use with [mince data model](https://github.com/asynchrony/mince_data_model) to make it easy to change from one data storage to another, like [Hashy Db](https://github.com/asynchrony/hashy_db), a Hash data persistence implementation, or [Mince](https://github.com/asynchrony/mince), a MongoDB implementation.
-
-# Why would you want this?
-
-- To defer choosing your database until you know most about your application.
-- Provides assitance in designing a database agnostic architecture.
-- When used along with [Hashy Db](https://github.com/asynchrony/hashy_db) it offers very little technical dependencies.  Use Hashy Db in development mode so that you can clone the repo and develop, and run tests, cucumbers without databases, migrations, etc.  Then in production mode, switch to Mince Dynamo DB.
-
-If you are able to switch between Hashy Db and Mince Dynamo Db, your application will be more open to new and improved database in the future, or as your application evolves you aren't tied to a database.
-
-
-# Todo
-
-- Write integration specs
-- Do not use singleton for data store
-- Refactor data store
-- Remove dependency on Active Support
-
-# Contribute
-
-- fork into a topic branch, write specs, make a pull request.
-
-# Owners
-
-Matt Simpson - [@railsgrammer](https://twitter.com/railsgrammer)
-
-# Contributors
-
-- Your name here!
-
-![Mince Some App](https://github.com/coffeencoke/gist-files/raw/master/images/mince%20garlic.png)

data/Rakefile

@@ -1,12 +0,0 @@
-require "bundler/gem_tasks"
-
-begin
-  require 'rspec/core/rake_task'
-
-  desc 'Default: run specs.'
-  task :default => :spec
-
-  desc "Run specs"
-  RSpec::Core::RakeTask.new 
-rescue LoadError
-end

data/lib/dynamo_db.rb

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

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

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

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

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

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

@@ -1,22 +0,0 @@
-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,31 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "dynamo_db/version"
-
-Gem::Specification.new do |s|
-  s.name        = "mince_dynamo_db"
-  s.version     = Mince::DynamoDb.version
-  s.authors     = ["Matt Simpson"]
-  s.email       = ["matt@railsgrammer.com"]
-  s.homepage    = "https://github.com/coffeencoke/mince_dynamo_db"
-  s.summary     = %q{Lightweight ORM for Amazon's DynamoDB with Ruby Apps}
-  s.description = %q{Lightweight ORM for Amazon's DynamoDB with Ruby Apps}
-
-  s.rubyforge_project = "mince_dynamo_db"
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-  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