mince_mongo_db 1.0.0.pre.1

data/lib/mongo_db/config.rb

@@ -0,0 +1,45 @@
+module Mince # :nodoc:
+  module MongoDb # :nodoc:
+    require 'singleton'
+
+    # = 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
+
+      def self.database_name
+        instance.database_name
+      end
+
+      def self.database_name=(val)
+        instance.database_name = val
+      end
+
+      def self.test_env_number
+        ENV['TEST_ENV_NUMBER']
+      end
+
+      attr_accessor :primary_key, :database_name
+
+      def initialize
+        self.primary_key = :_id
+        self.database_name = 'mince'
+      end
+
+      def database_name=(name)
+        @database_name = [name, self.class.test_env_number].compact.join("-")
+      end
+    end
+  end
+end

data/lib/mongo_db/connection.rb

@@ -0,0 +1,34 @@
+module Mince
+  module MongoDb
+    require_relative 'config'
+    require 'mongo'
+    require 'singleton'
+
+    class Connection
+      include Singleton
+
+      attr_accessor :connection, :db
+
+      def self.connection
+        instance.connection
+      end
+
+      def self.db
+        instance.db
+      end
+
+      def initialize
+        self.connection = Mongo::Connection.new
+      end
+
+      def connection=(con)
+        @connection = con
+        self.db = connection.db(database_name)
+      end
+
+      def database_name
+        Config.database_name
+      end
+    end
+  end
+end

data/lib/mongo_db/data_store.rb

@@ -0,0 +1,28 @@
+module Mince
+  module MongoDb
+    require 'singleton'
+    require_relative 'connection'
+
+    class DataStore
+      include Singleton
+
+      def self.collection(collection_name)
+        instance.collection(collection_name)
+      end
+
+      def self.db
+        instance.db
+      end
+
+      def collection(collection_name)
+        db.collection(collection_name)
+      end
+
+      attr_accessor :db
+
+      def initialize
+        self.db = Mince::MongoDb::Connection.db
+      end
+    end
+  end
+end

data/lib/mongo_db/interface.rb

@@ -0,0 +1,114 @@
+module Mince
+  module MongoDb
+    module Interface
+      require_relative 'data_store'
+      require_relative 'config'
+
+      def self.generate_unique_id(*args)
+        BSON::ObjectId.new.to_s
+      end
+
+      def self.primary_key
+        Config.primary_key
+      end
+
+      def self.delete_field(collection_name, key)
+        collection(collection_name).update({}, {"$unset" => { key => 1 } }, multi: true)
+      end
+
+      def self.delete_by_params(collection_name, params)
+        collection(collection_name).remove(params)
+      end
+
+      def self.add(collection_name, hash)
+        collection(collection_name).insert(hash)
+      end
+
+      def self.replace(collection_name, hash)
+        collection(collection_name).update({primary_key => hash[primary_key]}, hash)
+      end
+
+      def self.update_field_with_value(collection_name, primary_key_value, field_name, new_value)
+        collection(collection_name).update({primary_key => primary_key_value}, {'$set' => { field_name => new_value } })
+      end
+
+      def self.increment_field_by_amount(collection_name, primary_key_value, field_name, amount)
+        collection(collection_name).update({primary_key => primary_key_value}, {'$inc' => { field_name => amount } })
+      end
+
+      def self.get_all_for_key_with_value(collection_name, key, value)
+        get_by_params(collection_name, key.to_s => value)
+      end
+
+      def self.get_for_key_with_value(collection_name, key, value)
+        get_all_for_key_with_value(collection_name, key, value).first
+      end
+
+      def self.get_by_params(collection_name, hash)
+        collection(collection_name).find(hash)
+      end
+
+      def self.find_all(collection_name)
+        collection(collection_name).find
+      end
+
+      def self.find(collection_name, key, value)
+        collection(collection_name).find_one({key.to_s => value})
+      end
+
+      def self.push_to_array(collection_name, identifying_key, identifying_value, array_key, value_to_push)
+        collection(collection_name).update({identifying_key.to_s => identifying_value}, {'$push' => {array_key.to_s => value_to_push}})
+      end
+
+      def self.remove_from_array(collection_name, identifying_key, identifying_value, array_key, value_to_remove)
+        collection(collection_name).update({identifying_key.to_s => identifying_value}, {'$pull' => {array_key.to_s => value_to_remove}})
+      end
+
+      def self.containing_any(collection_name, key, values)
+        collection(collection_name).find({key.to_s => {"$in" => values}})
+      end
+
+      def self.array_contains(collection_name, key, value)
+        collection(collection_name).find(key.to_s => value)
+      end
+
+      def self.clear
+        db.collection_names.each do |collection_name|
+          db.drop_collection collection_name unless collection_name.include?('system')
+        end
+      end
+
+      def self.delete_collection(collection_name)
+        collection(collection_name).drop
+      end
+
+      def self.insert(collection_name, data)
+        data.each do |datum|
+          add collection_name, datum
+        end
+      end
+
+      def self.set_data(data)
+        clear
+
+        data.each do |key, value|
+          insert key, value
+        end
+      end
+
+      def self.data
+        db.collection_names.map do |collection_name|
+          find_all collection_name
+        end
+      end
+
+      def self.collection(collection_name)
+        DataStore.collection(collection_name)
+      end
+
+      def self.db
+        DataStore.db
+      end
+    end
+  end
+end

data/lib/mongo_db/version.rb

@@ -0,0 +1,21 @@
+module Mince
+  module MongoDb
+    module Version
+      def self.major
+        1
+      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/lib/mongo_db.rb

@@ -0,0 +1,9 @@
+module Mince
+  module MongoDb
+    require_relative 'mongo_db/config'
+    require_relative 'mongo_db/connection'
+    require_relative 'mongo_db/version'
+    require_relative 'mongo_db/data_store'
+    require_relative 'mongo_db/interface'
+  end
+end

data/spec/integration/mince_interface_spec.rb

@@ -0,0 +1,11 @@
+require_relative '../../lib/mongo_db'
+require 'mince/shared_examples/interface_example'
+
+describe 'Mince Interface with MongoDb' do
+  before do
+    Mince::Config.interface = Mince::MongoDb::Interface
+  end
+
+  it_behaves_like 'a mince interface'
+end
+

data/spec/units/mongo_db/config_spec.rb

@@ -0,0 +1,40 @@
+require_relative '../../../lib/mongo_db/config'
+
+describe Mince::MongoDb::Config do
+  it 'contains the primary key to used by the db interface' do
+    described_class.primary_key.should == :_id
+  end
+
+  describe 'the database name' do
+    subject { described_class.database_name }
+
+    it 'by default is "mince"' do
+      subject.should == 'mince'
+    end
+
+    it 'can be explicitly defined' do
+      described_class.database_name = 'custom_db_name'
+
+      subject.should == 'custom_db_name'
+
+      # Change name back because it is a singleton object
+      described_class.database_name = 'mince'
+    end
+
+    context 'when running parallel tests' do
+      before do
+        # Stubbing described_class because the method gets value from an environment
+        # variable, which is dangerous to change inside of a test and dangerous to
+        # stub
+        described_class.stub(:test_env_number => '1')
+
+        # Change name so that the test number is appended
+        described_class.database_name = 'mince'
+      end
+
+      it 'appends the test number to the db name' do
+        subject.should == 'mince-1'
+      end
+    end
+  end
+end

data/spec/units/mongo_db/connection_spec.rb

@@ -0,0 +1,18 @@
+require_relative '../../../lib/mongo_db/connection'
+
+describe Mince::MongoDb::Connection do
+  subject { described_class.instance }
+
+  let(:mongo_connection) { mock 'a mongo connection object', :db => db }
+  let(:db) { mock 'db'}
+  let(:database_name) { mock }
+
+  before do
+    Mince::MongoDb::Config.stub(database_name: database_name)
+    subject.connection = mongo_connection
+  end
+
+  it 'is a mongo connection' do
+    subject.connection.should == mongo_connection
+  end
+end

data/spec/units/mongo_db/data_store_spec.rb

@@ -0,0 +1,18 @@
+require_relative '../../../lib/mongo_db/data_store'
+
+describe Mince::MongoDb::DataStore do
+  let(:db) { mock }
+  let(:collection) { mock }
+  let(:collection_name) { mock }
+
+  before do
+    described_class.instance.db = db
+  end
+
+  it 'can return a specific collection and provides access to the db' do
+    db.stub(:collection).with(collection_name).and_return(collection)
+
+    described_class.collection(collection_name).should == collection
+    described_class.db.should == db
+  end
+end

data/spec/units/mongo_db/interface_spec.rb

@@ -0,0 +1,146 @@
+require_relative '../../../lib/mongo_db/interface'
+
+describe Mince::MongoDb::Interface do
+
+  let(:interface) { described_class }
+  let(:primary_key) { Mince::MongoDb::Config.primary_key }
+
+  let(:db) { mock 'mongo database' }
+  let(:mongo_data_store_connection) { mock 'mongo_data_store_connection', :db => db}
+  let(:collection) { mock 'some collection'}
+  let(:collection_name) { 'some_collection_name'}
+  let(:primary_key) { mock 'primary key'}
+  let(:mock_id) { mock 'id' }
+  let(:data) { { primary_key => mock_id}}
+  let(:return_data) { mock 'return data' }
+
+  before do
+    Mince::MongoDb::DataStore.stub(:db).and_return(db)
+    Mince::MongoDb::DataStore.stub(:collection).with(collection_name).and_return(collection)
+    Mince::MongoDb::Config.stub(primary_key: primary_key)
+  end
+
+  it 'uses the correct collection' do
+    interface.collection(collection_name).should == collection
+  end
+
+  it 'can delete a field' do
+    field = mock 'field to delete'
+    collection.should_receive(:update).with({}, {'$unset' => { field => 1 } }, multi: true)
+
+    interface.delete_field(collection_name, field)
+  end
+
+  it 'can delete all records the match a given set of params' do
+    params = mock 'params to condition the deleted records to'
+    collection.should_receive(:remove).with(params)
+
+    interface.delete_by_params(collection_name, params)
+  end
+
+  it 'can delete a collection' do
+    collection.should_receive(:drop)
+
+    interface.delete_collection(collection_name)
+  end
+
+  describe "Generating a primary key" do
+    let(:unique_id) { mock 'id' }
+    it 'should create a reasonably unique id' do
+      BSON::ObjectId.should_receive(:new).and_return(unique_id)
+
+      described_class.generate_unique_id('something').should == unique_id.to_s
+    end
+  end
+
+  it 'can write to the collection' do
+    collection.should_receive(:insert).with(data).and_return(return_data)
+
+    interface.add(collection_name, data).should == return_data
+  end
+
+  it 'can update a field with a specific value' do
+    key = mock 'key'
+    value = mock 'value'
+    id = mock 'id'
+    collection.should_receive(:update).with({ primary_key => id }, { '$set' => { key => value } })
+
+    interface.update_field_with_value collection_name, id, key, value
+  end
+
+  it 'can increment a field by a specific amount' do
+    key = mock 'key'
+    amount = mock 'amount to increment the field by'
+    id = mock 'id'
+    collection.should_receive(:update).with({ primary_key => id }, { '$inc' => { key => amount } })
+
+    interface.increment_field_by_amount collection_name, id, key, amount
+  end
+
+  it 'can read from the collection' do
+    collection.should_receive(:find).and_return(return_data)
+
+    interface.find_all(collection_name).should == return_data
+  end
+
+  it 'can replace a record' do
+    collection.should_receive(:update).with({primary_key => data[primary_key]}, data)
+
+    interface.replace(collection_name, data)
+  end
+
+  it 'can get one document' do
+    field = "stuff"
+    value = "more stuff"
+
+    collection.should_receive(:find_one).with(field => value).and_return(return_data)
+
+    interface.find(collection_name, field, value).should == return_data
+  end
+
+  it 'can clear the data store' do
+    collection_names = %w(collection_1 collection_2 system_profiles)
+    db.stub(:collection_names => collection_names)
+
+    db.should_receive(:drop_collection).with('collection_1')
+    db.should_receive(:drop_collection).with('collection_2')
+
+    interface.clear
+  end
+
+  it 'can get all records of a specific key value' do
+    collection.should_receive(:find).with({"key" => "value"}).and_return(return_data)
+
+    interface.get_all_for_key_with_value(collection_name, "key", "value").should == return_data
+  end
+
+  it 'can get a record of a specific key value' do
+    collection.should_receive(:find).with({"key" => "value"}).and_return([return_data])
+
+    interface.get_for_key_with_value(collection_name, "key", "value").should == return_data
+  end
+
+  it 'can get all records where a value includes any of a set of values' do
+    collection.should_receive(:find).with({"key1" => { "$in" => [1,2,4]} }).and_return(return_data)
+
+    interface.containing_any(collection_name, "key1", [1,2,4]).should == return_data
+  end
+
+  it 'can get all records where the array includes a value' do
+    collection.should_receive(:find).with({"key" => "value"}).and_return(return_data)
+
+    interface.array_contains(collection_name, "key", "value").should == return_data
+  end
+
+  it 'can push a value to an array for a specific record' do
+    collection.should_receive(:update).with({"key" => "value"}, { '$push' => { "array_key" => "value_to_push"}}).and_return(return_data)
+
+    interface.push_to_array(collection_name, :key, "value", :array_key, "value_to_push").should == return_data
+  end
+
+  it 'can remove a value from an array for a specific record' do
+    collection.should_receive(:update).with({"key" => "value"}, { '$pull' => { "array_key" => "value_to_remove"}}).and_return(return_data)
+
+    interface.remove_from_array(collection_name, :key, "value", :array_key, "value_to_remove").should == return_data
+  end
+end

metadata

@@ -0,0 +1,244 @@
+--- !ruby/object:Gem::Specification
+name: mince_mongo_db
+version: !ruby/object:Gem::Version
+  version: 1.0.0.pre.1
+  prerelease: 6
+platform: ruby
+authors:
+- Matt Simpson
+- Jason Mayer
+- Asynchrony
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-11-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.5.2
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: guard-rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        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.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.2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.0.pre.2
+- !ruby/object:Gem::Dependency
+  name: rb-fsevent
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.9.0
+description: Mince interface library to provide a lightweight MongoDB ORM for Ruby.
+email:
+- matt@railsgrammer.com
+- jason.mayer@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/mongo_db.rb
+- lib/mongo_db/config.rb
+- lib/mongo_db/connection.rb
+- lib/mongo_db/data_store.rb
+- lib/mongo_db/interface.rb
+- lib/mongo_db/version.rb
+- spec/integration/mince_interface_spec.rb
+- spec/units/mongo_db/config_spec.rb
+- spec/units/mongo_db/connection_spec.rb
+- spec/units/mongo_db/data_store_spec.rb
+- spec/units/mongo_db/interface_spec.rb
+homepage: https://github.com/coffeencoke/mince_mongo_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'
+      segments:
+      - 0
+      hash: 682498058529759032
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: mince_mongo_db
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Lightweight MongoDB ORM for Ruby.
+test_files:
+- spec/integration/mince_interface_spec.rb
+- spec/units/mongo_db/config_spec.rb
+- spec/units/mongo_db/connection_spec.rb
+- spec/units/mongo_db/data_store_spec.rb
+- spec/units/mongo_db/interface_spec.rb
+has_rdoc: