mince_dynamo_db 0.0.1

data/.gitignore

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

data/.rspec

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

data/.rvmrc

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

data/Gemfile

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

data/Guardfile

@@ -0,0 +1,11 @@
+# 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})                            { |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

@@ -0,0 +1,59 @@
+# 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 (not yet published)](#)
+
+# 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.add 'books', title: 'The World In Photographs', publisher: 'National Geographic'
+
+# Retrieve all records from the books collection
+MinceDynamoDb::DataStore.find_all 'books'
+
+# Replace a specific book
+MinceDynamoDb::DataStore.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

@@ -0,0 +1,12 @@
+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/mince_dynamo_db/connection.rb

@@ -0,0 +1,24 @@
+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_store.rb

@@ -0,0 +1,233 @@
+require 'singleton'
+require 'digest'
+require 'active_support/hash_with_indifferent_access'
+
+require_relative 'connection'
+
+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
+
+    # 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(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(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))
+    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))
+    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 => [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).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)
+    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)
+    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
+
+    # Takes a DynamoDB item and returns the attributes of that item as a hash
+    def to_hash(item)
+      item.attributes.to_h 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

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

data/lib/mince_dynamo_db.rb

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

data/mince_dynamo_db.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "mince_dynamo_db/version"
+
+Gem::Specification.new do |s|
+  s.name        = "mince_dynamo_db"
+  s.version     = MinceDynamoDb::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 "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"
+end

data/spec/integration/persisting_to_dynamodb_test.rb

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

data/spec/lib/connection_spec.rb

@@ -0,0 +1,20 @@
+require_relative '../../lib/mince_dynamo_db/connection'
+
+describe MinceDynamoDb::Connection do
+  subject { described_class.instance }
+
+  let(:connection) { mock 'an amazon dynamo db object' }
+  let(:access_key_id) { mock 'access key id provided by amazon'}
+  let(:secret_access_key) { mock 'secret access key provided by amazon'}
+  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)
+  end
+
+  it 'has a dynamo db connection' do
+    AWS::DynamoDB.should_receive(:new).with(access_key_id: access_key_id, secret_access_key: secret_access_key).and_return(connection)
+
+    subject.connection.should == connection
+  end
+end

data/spec/lib/data_store_spec.rb

@@ -0,0 +1,133 @@
+require_relative '../../lib/mince_dynamo_db/data_store'
+
+describe MinceDynamoDb::DataStore do
+  subject { described_class.instance }
+
+  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(:collection_name) { 'some_collection_name'}
+  let(:primary_key) { mock 'primary key'}
+  let(:mock_id) { mock 'id' }
+  let(:data) { { :_id => mock_id}}
+  let(:return_data) { mock 'return data', attributes: attributes }
+  let(:attributes) { mock 'attributes', to_h: hash }
+  let(:hash) { mock 'hash' }
+  let(:items) { mock 'items' }
+
+  before do
+    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'
+  end
+
+  describe "Generating a primary key" do
+    let(:unique_id) { '123456789012345' }
+    let(:time) { mock 'time' }
+    let(:salt) { mock 'salt' }
+
+    before do
+      Time.stub_chain('current.utc' => time)
+    end
+
+    it 'should create a reasonably unique id' do
+      Digest::SHA256.should_receive(:hexdigest).with("#{time}#{salt}").and_return(unique_id)
+      shorter_id = unique_id.to_s[0..6]
+
+      described_class.generate_unique_id(salt).should == shorter_id
+    end
+  end
+
+  it 'can write to the collection' do
+    items.should_receive(:create).with(data).and_return(return_data)
+
+    subject.add(collection_name, data).should == return_data
+  end
+
+  it 'can read from the collection' do
+    item_hash = mock 'hash of attributes for an item'
+    item_attributes = mock 'attributes for an item', to_h: item_hash
+    item = mock 'item', attributes: item_attributes
+    collection.stub(items: [item])
+
+    subject.find_all(collection_name).should == [item_hash]
+  end
+
+  it 'can replace a record' do
+    items.should_receive(:put).with(data)
+
+    subject.replace(collection_name, data)
+  end
+
+  it 'can get one document' do
+    field = "stuff"
+    value = "more stuff"
+
+    items.should_receive(:where).with(field => value).and_return([return_data])
+    
+    subject.find(collection_name, field, value).should == hash
+  end
+
+  it 'can clear the data store' do
+    item = mock 'item', delete: nil
+    item2 = mock 'item 2', delete: nil
+    collection_1 = mock 'collection 1', name: 'collection 1', schema_loaded?: true, items: [item]
+    collection_2 = mock 'collection 2', name: 'collection 2', schema_loaded?: true, items: [item2]
+    collections = [collection_1, collection_2]
+
+    db.stub(:tables => collections)
+
+    item.should_receive(:delete)
+    item2.should_receive(:delete)
+    
+    subject.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 == [hash]
+  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 == hash
+  end
+
+  it 'can get all records where a value includes any of a set of values' do
+    filter = mock 'filter', in: return_data
+    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 == [hash]
+  end
+
+  it 'can get all records where the array includes a value' do
+    filter = mock 'filter', contains: return_data
+    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 == [hash]
+  end
+
+  it 'can push a value to an array for a specific record' do
+    items.should_receive(:where).with("key" => "value").and_return([return_data])
+    attributes.should_receive(:add).with(:array_key => ["value_to_push"])
+
+    subject.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")
+  end
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: mince_dynamo_db
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Matt Simpson
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: &70289094931040 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.7
+  type: :runtime
+  prerelease: false
+  version_requirements: *70289094931040
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &70289094958080 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *70289094958080
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70289094957560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.8.0
+  type: :development
+  prerelease: false
+  version_requirements: *70289094957560
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: &70289094956900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *70289094956900
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: &70289094956260 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.7.5
+  type: :development
+  prerelease: false
+  version_requirements: *70289094956260
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: &70289094955340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.1.1
+  type: :development
+  prerelease: false
+  version_requirements: *70289094955340
+description: Lightweight ORM for Amazon's DynamoDB with Ruby Apps
+email:
+- matt@railsgrammer.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .rvmrc
+- Gemfile
+- Guardfile
+- README.md
+- Rakefile
+- lib/mince_dynamo_db.rb
+- lib/mince_dynamo_db/connection.rb
+- lib/mince_dynamo_db/data_store.rb
+- lib/mince_dynamo_db/version.rb
+- mince_dynamo_db.gemspec
+- spec/integration/persisting_to_dynamodb_test.rb
+- spec/lib/connection_spec.rb
+- spec/lib/data_store_spec.rb
+- spec/support/aws_example.yml
+homepage: https://github.com/coffeencoke/mince_dynamo_db
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: mince_dynamo_db
+rubygems_version: 1.8.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_store_spec.rb
+- spec/support/aws_example.yml
+has_rdoc: