hashy_db 1.1.0 → 2.0.0.pre

data/lib/hashy_db/config.rb

@@ -0,0 +1,18 @@
+module Mince
+  module HashyDb # :nodoc:
+    # = HashyDb Config
+    #
+    # HashyDb Config specifies the configuration settings for HashyDb
+    #
+    # @author Matt Simpson
+    module Config
+      # 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
+        :id
+      end
+    end
+  end
+end

data/lib/hashy_db/data_store.rb

@@ -1,123 +1,55 @@
-# SRP: Model with implementation on how to store each collection in a data store
-require 'singleton'
-require 'active_support/core_ext/module/delegation'
-require 'digest'
-
-module HashyDb
-  class DataStore
-    include Singleton
-
-    def self.primary_key_identifier
-      :id
-    end
-
-    def self.generate_unique_id(salt)
-      Digest::SHA256.hexdigest("#{Time.current.utc}#{salt}")[0..6]
-    end
-
-    def delete_field(collection_name, field)
-      find_all(collection_name).each do |row|
-        row.delete(field)
+module Mince
+  module HashyDb # :nodoc:
+    require 'singleton'
+
+    # = HashyDb Data Store
+    #
+    # HashyDb Data Store stores and retrieves data from a ruby in-memory hash.
+    #
+    # 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.
+    #
+    # HashyDb Data Store is a singleton object that provides class level interface to the singleton instance.
+    #
+    #   Mince::HashyDb::DataStore.instance # => Mince::HashyDb::DataStore object
+    #   Mince::HashyDb::DataStore.data # => returns all data stored in the HashyDb database
+    #   Mince::HashyDb::DataStore.collection(:some_collection) # => returns all data stored in a specific collection in the HashyDb database
+    #
+    # @author Matt Simpson
+    class DataStore
+      include Singleton
+
+      # Sets the entire data store, for all collections
+      #
+      # @param [Hash] hash the hash to replace the entire data store with
+      def self.set_data(hash)
+        instance.data = hash
       end
-    end
-
-    def add(collection_name, hash)
-      find_all(collection_name) << hash
-    end
-
-    def replace(collection_name, hash)
-      collection = find_all(collection_name)
-      index = collection.index{ |object| object[:id] == hash[:id] }
-      collection[index] =  hash
-    end
 
-    def delete_by_params(collection_name, params)
-      find_all(collection_name).reject! do |record|
-        params.all?{|k,v| record[k] == v }
+      # Class level access to the in-memory data store
+      #
+      # @return [Hash] all collections along with the contents of each collection
+      def self.data
+        instance.data
       end
-    end
-
-    def update_field_with_value(collection_name, primary_key_value, field_name, new_value)
-      find(collection_name, :id, primary_key_value)[field_name] = new_value
-    end
 
-    def increment_field_by_amount(collection_name, primary_key_value, field_name, amount)
-      find(collection_name, :id, primary_key_value)[field_name] += amount
-    end
-
-    def get_all_for_key_with_value(collection_name, key, value)
-      find_all(collection_name).select { |a| a[key] == value }
-    end
-
-    def get_for_key_with_value(collection_name, key, value)
-      get_all_for_key_with_value(collection_name, key, value)[0]
-    end
-
-    def get_by_params(collection_name, hash)
-      find_all(collection_name).select do |record|
-        hash.all?{|k,v| record[k] == v }
+      # The collection in the data store
+      #
+      # @param [Symbol] collection_name the name of the collection
+      # @return [Array] all records in the collection, defaults to an empty array
+      def self.collection(collection_name)
+        data[collection_name] ||= []
       end
-    end
 
-    def find_all(collection_name)
-      data_store[collection_name] ||= []
-    end
+      # The attribute containing the data
+      #
+      # @return [Hash] all collections along with the contents of each collection, defaults to an empty hash
+      attr_accessor :data
 
-    def find(collection_name, key, value)
-      find_all(collection_name).find { |x| x[key] == value }
-    end
-
-    def push_to_array(collection_name, identifying_key, identifying_value, array_key, value_to_push)
-      record = find(collection_name, identifying_key, identifying_value)
-      if (record[array_key])
-        record[array_key] << value_to_push
-      else
-        record[array_key] = [value_to_push]
+      def initialize
+        @data = {}
       end
-      record[array_key].uniq!
-    end
-
-    def remove_from_array(collection_name, identifying_key, identifying_value, array_key, value_to_pop)
-      record = find(collection_name, identifying_key, identifying_value)
-      record[array_key].reject! { |x| x == value_to_pop }
-    end
-
-    def containing_any(collection_name, key, values)
-      find_all(collection_name).select do |x|
-        if x[key].is_a?(Array)
-          (x[key] & values).any?
-        else
-          values.include?(x[key])
-        end
-      end
-    end
-
-    def array_contains(collection_name, key, value)
-      find_all(collection_name).select do |x|
-        x[key] && x[key].include?(value)
-      end
-    end
-
-    def delete_collection(collection_name)
-      data_store.delete(collection_name)
-    end
-
-    def clear
-      data_store.clear
-    end
-
-    def insert(collection_name, data)
-      data_store[collection_name] = data
-    end
-
-    def set_data_store(hash)
-      @data_store = hash
-    end
-
-    private
-
-    def data_store
-      @data_store ||= ::DB_HASH
     end
   end
 end

data/lib/hashy_db/interface.rb

@@ -0,0 +1,237 @@
+module Mince
+  module HashyDb # :nodoc:
+    require 'digest'
+    require_relative 'data_store'
+    require_relative 'config'
+
+    # = HashyDb Data Store
+    #
+    # HashyDb Data Store stores and retrieves data from a ruby in-memory hash.
+    #
+    # 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.
+    #
+    #   HashyDb::DataStore.add 'fruits', id: '1', name: 'Shnawzberry', color: 'redish', quantity: '20'
+    #   HashyDb::DataStore.get_for_key_with_value 'fruits', :color, 'redish'
+    #
+    # @author Matt Simpson
+    module Interface
+
+      # 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.now}#{salt}")[0..6]
+      end
+
+      def self.primary_key
+        Config.primary_key
+      end
+
+      # Deletes a field from all records in the given collection
+      #
+      # @param [Symbol] collection_name the name of the collection
+      # @param [symbol] field the name of the field to delete
+      def self.delete_field(collection_name, field)
+        find_all(collection_name).each do |row|
+          row.delete(field)
+        end
+      end
+
+      # Inserts one record into a collection.
+      #
+      # @param [Symbol] 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)
+        find_all(collection_name) << 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 [Symbol] 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)
+        collection = find_all(collection_name)
+        index = collection.index{ |object| object[primary_key] == hash[primary_key] }
+        collection[index] =  hash
+      end
+
+      # Deletes a record that matches the given criteria from the data store.
+      def self.delete_by_params(collection_name, params)
+        find_all(collection_name).reject! do |record|
+          params.all?{|k,v| record[k] == v }
+        end
+      end
+
+      # Updates the field with a value for the record for the given id.
+      #
+      # @param [Symbol] collection_name the name of the collection
+      # @param [String] primary_key_value the id of the record
+      # @param [Symbol] field_name the name of the field to update
+      # @param [String] field_value the value to update the field to
+      # @return [void] no specific return value
+      def self.update_field_with_value(collection_name, primary_key_value, field_name, new_value)
+        find(collection_name, primary_key, primary_key_value)[field_name] = new_value
+      end
+
+      # Increments or decrements the field by the given amount for the record for the given id.
+      #
+      # @param [Symbol] collection_name the name of the collection
+      # @param [String] primary_key_value the id of the record
+      # @param [Symbol] field_name the name of the field to update
+      # @param [String] amount the amount to increment or decrement the field by
+      # @return [void] no specific return value
+      def self.increment_field_by_amount(collection_name, primary_key_value, field_name, amount)
+        find(collection_name, primary_key, primary_key_value)[field_name] += amount
+      end
+
+      # Gets all records that have the value for a given key.
+      #
+      # @param [Symbol] 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)
+        find_all(collection_name).select { |a| a[key] == value }
+      end
+
+      # Gets the first record that has the value for a given key.
+      #
+      # @param [Symbol] 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)
+        self.get_all_for_key_with_value(collection_name, key, value)[0]
+      end
+
+      # Gets all records that have all of the keys and values in the given hash.
+      #
+      # @param [Symbol] 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)
+        self.find_all(collection_name).select do |record|
+          hash.all?{|k,v| record[k] == v }
+        end
+      end
+
+      # Gets all records for a collection
+      #
+      # @param [Symbol] collection_name the name of the collection
+      # @return [Array] all records for the given collection name
+      def self.find_all(collection_name)
+        DataStore.collection(collection_name)
+      end
+
+      # Gets a record matching a key and value
+      #
+      # @param [Symbol] 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)
+        find_all(collection_name).find { |x| x[key] == value }
+      end
+
+      # Pushes a value to a record's key that is an array
+      #
+      # @param [Symbol] 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)
+        record = find(collection_name, identifying_key, identifying_value)
+        if (record[array_key])
+          record[array_key] << value_to_push
+        else
+          record[array_key] = [value_to_push]
+        end
+        record[array_key].uniq!
+      end
+
+      # Removes a value from a record's key that is an array
+      #
+      # @param [Symbol] 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_pop)
+        record = find(collection_name, identifying_key, identifying_value)
+        record[array_key].reject! { |x| x == value_to_pop }
+      end
+
+      # Returns all records where the given key contains any of the values provided
+      #
+      # @param [Symbol] 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)
+        find_all(collection_name).select do |x|
+          if x[key].is_a?(Array)
+            (x[key] & values).any?
+          else
+            values.include?(x[key])
+          end
+        end
+      end
+
+      # Returns all records where the given key contains the given value
+      #
+      # @param [Symbol] 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)
+        find_all(collection_name).select do |x|
+          x[key] && x[key].include?(value)
+        end
+      end
+
+      # Replaces the entire collection with the given data
+      #
+      # @param [Symbol] collection_name the name of the collection
+      # @param [Array] data an array of data hashes to replace and insert into the collection
+      def self.insert(collection_name, data_to_insert)
+        data[collection_name] = data_to_insert
+      end
+
+      # Deletes an entire collection
+      #
+      # @param [Symbol] collection_name the collection to delete from the database
+      # @return [Array] the records in the collection being deleted
+      def self.delete_collection(collection_name)
+        data.delete(collection_name)
+      end
+
+      # Clears the data store.
+      #
+      # Mainly used for rolling back the data store for tests.
+      #
+      # @return [Hash] the data store
+      def self.clear
+        data.clear
+      end
+
+      # Alias to Mince::HashyDb::DataStore.data=
+      def self.set_data(hash)
+        DataStore.set_data hash
+      end
+
+      # Alias to Mince::HashyDb::DataStore.data
+      def self.data
+        DataStore.data
+      end
+    end
+  end
+end

data/lib/hashy_db/version.rb

@@ -1,3 +1,35 @@
-module HashyDb
-  VERSION = '1.1.0'
+module HashyDb # :nodoc:
+  # = HashyDb Version
+  #
+  # HashyDb Version specifies the version of this library
+  #
+  # Use these versions to negotiate with for compatibility
+  #
+  # Major version releases indicates a major enhancement, breaks backward compatibility
+  # Minor version release indicates an addition, enhancement or bug fix which is not an immediate need, does not break backward compatibility
+  # Patch version release indicates a bug fix or patch that is an emergency, does not break backward compatibility
+  #
+  # @author Matt Simpson
+  module Version
+
+    # Provides the major level version of the library
+    def self.major
+      2
+    end
+
+    # Provides the minor level version of the library
+    def self.minor
+      0
+    end
+
+    # Provides the patch level version of the library
+    def self.patch
+      '0.pre'
+    end
+  end
+
+  # Provides the full version of the library
+  def self.version
+    [Version.major, Version.minor, Version.patch].join(".")
+  end
 end

data/lib/hashy_db.rb

@@ -1 +1,4 @@
-require 'hashy_db/data_store'
+require_relative 'hashy_db/version'
+require_relative 'hashy_db/config'
+require_relative 'hashy_db/data_store'
+require_relative 'hashy_db/interface'

data/spec/integration/mince_interface_spec.rb

@@ -0,0 +1,14 @@
+require_relative '../../lib/hashy_db'
+require 'mince/shared_examples/interface_example'
+
+describe 'Mince Interface with HashyDb' do
+  before do
+    Mince::Config.interface = Mince::HashyDb::Interface
+  end
+
+  after do
+    Mince::HashyDb::Interface.clear
+  end
+
+  it_behaves_like 'a mince interface'
+end

data/spec/units/hashy_db/config_spec.rb

@@ -0,0 +1,7 @@
+require_relative '../../../lib/hashy_db/config'
+
+describe Mince::HashyDb::Config do
+  it 'it knows what to use for the primary key of each record' do
+    described_class.primary_key.should == :id
+  end
+end

data/spec/units/hashy_db/data_store_spec.rb

@@ -0,0 +1,21 @@
+require_relative '../../../lib/hashy_db/data_store'
+
+describe Mince::HashyDb::DataStore do
+  it 'has no data by default' do
+    described_class.data.should == {}
+  end
+
+  it 'can add data' do
+    data = mock
+    described_class.set_data(data)
+
+    described_class.data.should == data
+  end
+
+  it 'can return a collection' do
+    data = mock
+    described_class.set_data({ some_collection: data })
+
+    described_class.collection(:some_collection).should == data
+  end
+end

data/spec/units/hashy_db/interface_spec.rb

@@ -0,0 +1,8 @@
+require_relative '../../../lib/hashy_db/interface'
+
+describe Mince::HashyDb::Interface do
+  # due to the low level behavior of this class, it is tested at the integration level
+  # at spec/integration/mince_interface_spec.rb
+  #
+  # Feel free to provide a better implementation of this.
+end

metadata

@@ -1,67 +1,134 @@
 --- !ruby/object:Gem::Specification
 name: hashy_db
 version: !ruby/object:Gem::Version
-  version: 1.1.0
-  prerelease: 
+  version: 2.0.0.pre
+  prerelease: 6
 platform: ruby
 authors:
 - Matt Simpson
 - Jason Mayer
-- Asynchrony Solutions
+- Asynchrony
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-08 00:00:00.000000000 Z
+date: 2012-10-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.1'
-  type: :runtime
+        version: '0.9'
+  type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '3.1'
+        version: '0.9'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: rspec
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '2.0'
 - !ruby/object:Gem::Dependency
-  name: rspec
+  name: guard-rspec
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.6'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     none: false
     requirements:
-    - - ! '>='
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.6'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
-description: Provides an interface to store and retrieve data in a Hash.
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: redcarpet
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: debugger
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: mince
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.0.pre
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.0.pre
+description: Library to interact with in-memory hash database collections. Offers
+  very little technical dependencies.  In order to develop or run the tests for your
+  application you just need ruby installed, run bundle install and you're good to
+  go.  No need to install and start your database, migrate, etc.
 email:
 - matt@railsgrammer.com
 - jason.mayer@gmail.com
@@ -69,18 +136,15 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .rspec
-- .rvmrc
-- Gemfile
-- LICENSE.txt
-- README.md
-- Rakefile
-- hashy_db.gemspec
 - lib/hashy_db.rb
 - lib/hashy_db/data_store.rb
 - lib/hashy_db/version.rb
-- spec/lib/data_store_spec.rb
+- lib/hashy_db/config.rb
+- lib/hashy_db/interface.rb
+- spec/integration/mince_interface_spec.rb
+- spec/units/hashy_db/config_spec.rb
+- spec/units/hashy_db/data_store_spec.rb
+- spec/units/hashy_db/interface_spec.rb
 homepage: https://github.com/asynchrony/hashy_db
 licenses: []
 post_install_message: 
@@ -96,15 +160,18 @@ required_ruby_version: !ruby/object:Gem::Requirement
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
-  - - ! '>='
+  - - ! '>'
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
 rubyforge_project: hashy_db
 rubygems_version: 1.8.24
 signing_key: 
 specification_version: 3
-summary: Provides an interface to store and retrieve data in a Hash.
+summary: Library to interact with in-memory hash database collections
 test_files:
-- spec/lib/data_store_spec.rb
+- spec/integration/mince_interface_spec.rb
+- spec/units/hashy_db/config_spec.rb
+- spec/units/hashy_db/data_store_spec.rb
+- spec/units/hashy_db/interface_spec.rb
 has_rdoc: 

data/.gitignore

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

data/.rspec

@@ -1,2 +0,0 @@
---colour
---format nested

data/.rvmrc

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

data/Gemfile

@@ -1,3 +0,0 @@
-source :rubygems
-
-gemspec

data/LICENSE.txt

@@ -1,20 +0,0 @@
-Copyright (c) 2012 Matt Simpson and Jason Mayer
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
-NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
-LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -1,65 +0,0 @@
-# What is hashy db?
-
-Light weight ORM to persist data to a hash. 
-
-Provides an interface for storing and retreiving information to a Hash.
-
-The motivation behind this is so you can clone the repository down, have ruby installed, run bundle install and be able to run your tests and develop without being dependent on any other setup.
-
-[@github](https://github.com/asynchrony/HashyDB)
-[@rubygems](https://rubygems.org/gems/hashy_db)
-
-# How to use
-
-view the [example mince rails app](https://github.com/coffeencoke/mince_rails_example) to see how to use this.
-
-Basic usage is to create a constant called DB_HASH and set it to an empty hash in an initializer file, or whenever your application gets loaded (if you're not running rails).
-
-<pre>
-# initializers/datastore.rb
-::DB_HASH = {}
-</pre>
-
-From there you can use Hashy Db to add and retrieve data.
-
-<pre>
-# Add a book to the books collection
-HashyDb::DataStore.add 'books', title: 'The World In Photographs', publisher: 'National Geographic'
-
-# Retrieve all records from the books collection
-HashyDb::DataStore.find_all 'books'
-
-# Update a field with a value for a specific record
-HashyDb::DataStore.update_field_with_value 'books', 'primary_id_123', :field_name, 'value to update with'
-
-# Replace a specific book
-HashyDb::DataStore.replace 'books', id: 1, title: 'A World In Photographs', publisher: 'National Geographic'
-</pre>
-
-View the [data_store.rb](https://github.com/asynchrony/hashy_db/blob/master/lib/hashy_db/data_store.rb) file 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 [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.
-- Offers very little technical dependencies.  In order to develop or run the tests for your application you just need ruby installed, run bundle install and you're good to go.  No need to install and start your database, migrate, etc.
-
-The hash can be loaded in memory and be used as your data store.  
-
-# Contribute
-
-- fork into a topic branch, write specs, make a pull request.
-
-# Owners
-
-Matt Simpson - [@railsgrammer](https://twitter.com/railsgrammer)
-
-Jason Mayer - [@farkerhaiku](https://twitter.com/farkerhaiku)
-
-# Contributors
-
-David Czarnecki - [@czarneckid](https://twitter.com/czarneckid)
-Amos King - [@adkron](https://twitter.com/adkron)

data/Rakefile

@@ -1,11 +0,0 @@
-require 'bundler/gem_tasks'
-require 'rake'
-require 'rspec/core/rake_task'
-
-RSpec::Core::RakeTask.new(:spec) do |spec|
-  spec.pattern = 'spec/**/*_spec.rb'
-  spec.rspec_opts = ['--backtrace']
-  # spec.ruby_opts = ['-w']
-end
-
-task :default => :spec

data/hashy_db.gemspec

@@ -1,25 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require 'hashy_db/version'
-
-Gem::Specification.new do |s|
-  s.name        = "hashy_db"
-  s.version     = HashyDb::VERSION
-  s.authors     = ["Matt Simpson", "Jason Mayer", "Asynchrony Solutions"]
-  s.email       = ["matt@railsgrammer.com", "jason.mayer@gmail.com"]
-  s.homepage    = "https://github.com/asynchrony/hashy_db"
-  s.summary     = %q{Provides an interface to store and retrieve data in a Hash.}
-  s.description = %q{Provides an interface to store and retrieve data in a Hash.}
-
-  s.rubyforge_project = "hashy_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('activesupport', '~> 3.1')
-  
-  s.add_development_dependency('rake')
-  s.add_development_dependency('rspec')
-end

data/spec/lib/data_store_spec.rb

@@ -1,137 +0,0 @@
-require_relative '../../lib/hashy_db/data_store'
-
-describe HashyDb::DataStore do
-  subject { HashyDb::DataStore.instance }
-
-  let(:data1) { {id: 1, field_1: 'value 1', field_2: 3, field_3: [1, 2, 3], shared_between_1_and_2: 'awesome_value', :some_array => [1, 2, 3, 4]} }
-  let(:data2) { {id: 2, field_1: 'value 1.2', field_2: 6, shared_between_1_and_2: 'awesome_value', :some_array => [4, 5, 6]} }
-  let(:data3) { {id: 3, field_1: 'value 3', field_2: 9, shared_between_1_and_2: 'not the same as 1 and 2', :some_array => [1, 7]} }
-
-  before do
-    subject.set_data_store({})
-
-    subject.insert(:some_collection, [data1, data2, data3])
-  end
-
-  it 'has a primary key identifier' do
-    described_class.primary_key_identifier.should == :id
-  end
-
-  describe "Generating a primary key" do
-    let(:data_model_id) { full_data_model_id[0..6] }
-    let(:full_data_model_id) { '1234567891423456789' }
-    let(:utc) { mock 'utc'}
-    let(:time) { mock 'time', :utc => utc}
-    let(:salt) { mock 'salt to ensure uniqeness' }
-
-    before do
-      Digest::SHA256.stub(:hexdigest => full_data_model_id)
-      Time.stub(:current => time)
-    end
-
-    it 'should create a reasonably unique id' do
-      Digest::SHA256.should_receive(:hexdigest).with("#{utc}#{salt}").and_return(full_data_model_id)
-
-      described_class.generate_unique_id(salt).should == data_model_id
-    end
-  end
-
-  it 'can delete a field' do
-    subject.delete_field(:some_collection, :field_1)
-
-    subject.find_all(:some_collection).each do |row|
-      row.has_key?(:field_1).should be_false
-    end
-  end
-
-  it 'can delete a collection' do
-    subject.delete_collection(:some_collection)
-    
-    subject.find_all(:some_collection).should == []
-  end
-
-  it 'can delete records that match a given set of fields' do
-    params = { id: 1, field_1: 'value 1' }
-
-    subject.delete_by_params(:some_collection, params)
-
-    subject.find_all(:some_collection).should == [data2, data3]
-  end
-
-  it 'can write and read data to and from a collection' do
-    data4 = {id: 3, field_1: 'value 3', field_2: 9, shared_between_1_and_2: 'not the same as 1 and 2', :some_array => [1, 7]}
-
-    subject.add(:some_collection, data4)
-    subject.find_all(:some_collection).should == [data1, data2, data3, data4]
-  end
-
-  it 'can replace a record' do
-    data2[:field_1] = 'value modified'
-    subject.replace(:some_collection, data2)
-
-    subject.find(:some_collection, :id, 2)[:field_1].should == 'value modified'
-  end
-
-  it 'can update a field with a value on a specific record' do
-    subject.update_field_with_value(:some_collection, 3, :field_2, '10')
-    
-    subject.find(:some_collection, :id, 3)[:field_2].should == '10'
-  end
-
-  it 'can increment a field with a given amount for a specific field' do
-    subject.increment_field_by_amount(:some_collection, 1, :field_2, 3)
-    
-    subject.find(:some_collection, :id, 1)[:field_2].should == 6
-  end
-
-  it 'can get one document' do
-    subject.find(:some_collection, :field_1, 'value 1').should == data1
-    subject.find(:some_collection, :field_2, 6).should == data2
-  end
-
-  it 'can clear the data store' do
-    subject.clear
-
-    subject.find_all(:some_collection).should == []
-  end
-
-  it 'can get all records of a specific key value' do
-    subject.get_all_for_key_with_value(:some_collection, :shared_between_1_and_2, 'awesome_value').should == [data1, data2]
-  end
-
-  it 'can get all records where a value includes any of a set of values' do
-    subject.containing_any(:some_collection, :some_array, []).should == []
-    subject.containing_any(:some_collection, :some_array, [7, 2, 3]).should == [data1, data3]
-    subject.containing_any(:some_collection, :id, [1, 2, 5]).should == [data1, data2]
-  end
-
-  it 'can get all records where the array includes a value' do
-    subject.array_contains(:some_collection, :some_array, 1).should == [data1, data3]
-    subject.array_contains(:some_collection, :some_array_2, 1).should == []
-  end
-
-  it 'can push a value to an array for a specific record' do
-    subject.push_to_array(:some_collection, :id, 1, :field_3, 'add to existing array')
-    subject.push_to_array(:some_collection, :id, 1, :new_field, 'add to new array')
-
-    subject.find(:some_collection, :id, 1)[:field_3].should include('add to existing array')
-    subject.find(:some_collection, :id, 1)[:new_field].should == ['add to new array']
-  end
-
-  it 'can remove a value from an array for a specific record' do
-    subject.remove_from_array(:some_collection, :id, 1, :field_3, 2)
-
-    subject.find(:some_collection, :id, 1)[:field_3].should_not include(2)
-  end
-
-  it 'can get all records that match a given set of keys and values' do
-    records = subject.get_by_params(:some_collection, field_1: 'value 1', shared_between_1_and_2: 'awesome_value')
-    records.size.should be(1)
-    records.first[:id].should == 1
-    subject.find_all(:some_collection).size.should == 3
-  end
-
-  it 'can get a record for a specific key and value' do
-    subject.get_for_key_with_value(:some_collection, :field_1, 'value 1').should == data1
-  end
-end