rmodel 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: deb9462cdda8354cf1ae328254df31b82ddd3a74
+  data.tar.gz: 98e72a0ff775b44114b7c90383046806f15948db
+SHA512:
+  metadata.gz: dd4006a1d057a592bac459e31f39039c496a89d9c379c7953bea129bc8e3acbd92f13b7cd6d2c32a5ad8ee8a71caebdd8b72a9cd328de1ed41f697ab033b8be3
+  data.tar.gz: d3e1d56effdceeb17d3978b8242f35aaf9689b2eddf5b71fffc30e6665aea25972672bddcf1d1d3f4053559ffe59cc7d74362cacb5d7877befcaf10cf5c33279

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.rspec

@@ -0,0 +1,3 @@
+--format doc
+--color
+--require spec_helper

data/.travis.yml

@@ -0,0 +1,9 @@
+language: ruby
+script: rspec
+rvm:
+  - 1.9.3
+  - 2.0.0
+  - 2.1.7
+  - 2.2.3
+services:
+  - mongodb

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Alexei
+
+MIT License
+
+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

@@ -0,0 +1,165 @@
+[![Build Status](https://travis-ci.org/alexei-lexx/rmodel.svg)](https://travis-ci.org/alexei-lexx/rmodel)
+
+# Rmodel
+
+Rmodel is an ORM library, which tends to follow the SOLID principles.
+
+The main thoughts behind it are:
+
+* let you models be simple and independent of the persistent layer,
+* be able to switch the persistent layer at any moment,
+* keep the simplicity of the Active Record pattern by default,
+* be able to implement any type of persistence: SQL, NoSQL, files, HTTP etc.
+
+It consists of 3 major components:
+
+1. **Entities**; ex.: User, Order etc.
+2. **Repositories**, which are used to fetch, save and delete entities; ex.: UserRepository, OrderRepository
+3. **Factories**, which play the role of mappers.
+
+Basic implemented features:
+
+1. CRUD operations: `find`, `insert`, `update`, `remove`;
+2. Scopes: `userRepository.query.recent.sorted`
+3. Based on query operations: `userRepository.query.recent.remove`
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'rmodel'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rmodel
+
+## Usage
+
+Let's define an entity
+
+```ruby
+class User
+  attr_accessor :id, :name, :email
+end
+```
+
+As you see it's a plain ruby class with attributes. It must have either the zero-argument `#initialize` method or no `#initialize` at all.
+
+Of course we need a repository to save users.
+
+```ruby
+require 'rmodel' # dont forget to require the gem
+
+class User
+  attr_accessor :id, :name, :email
+end
+
+class UserRepository < Rmodel::Mongo::Repository
+end
+
+userRepository = UserRepository.new
+```
+The code above raises the exception *Client driver is not setup (ArgumentError)*. UserRepository derives from Rmodel::Mongo::Repository, which uses the ruby mongo driver to access the database. We must provide the appropriate connection options. To do this we use the following code:
+
+```ruby
+require 'rmodel'
+
+Rmodel.setup do
+  client :default, { hosts: [ 'localhost' ], database: 'test' }
+end
+```
+
+The `:default` client is used by every repository that doesn't specify it's client explicitly.
+
+Run the code again and get another error *Factory can not be guessed (ArgumentError)*. The factory is used to convert the array of database tuples (hashes) to the array of User objects.
+
+```ruby
+class UserRepository < Rmodel::Mongo::Repository
+  simple_factory User, :name, :email
+end
+```
+
+The `simple_factory` class macro says that every database tuple will be straightforwardly converted to an instance of User with  attributes :id, :name and :email. There is no need to specify :id, because it's required.
+
+### CRUD
+
+Let's create and insert several users.
+
+```ruby
+john = User.new('John', 'john@example.com')
+bill = User.new('Bill', 'bill@example.com')
+bob = User.new('Bob', 'bob@example.com')
+
+userRepository.insert(john)
+userRepository.insert(bill)
+userRepository.insert(bob)
+```
+
+Now you can check you `test` database. There are 3 new users there. Print the `john`. As you can see it's got the `@id`.
+
+```ruby
+p john
+#<User:0x00... @name="John", @email="john@example.com", @id=BSON::ObjectId('562a...')>
+```
+
+Let's update John and remove Bob.
+
+```ruby
+john.name = 'John Smith'
+userRepository.update(john)
+
+userRepository.remove(bob)
+
+p userRepository.find(john.id) # #<User:0x000000037237d0 @name="John Smith" ... >
+p userRepository.find(bob.id) # nil
+p userRepository.find!(bob.id) # nil
+```
+
+### Scopes
+
+Scopes are defined inside the repository.
+
+```ruby
+class UserRepository < Rmodel::Mongo::Repository
+  simple_factory User, :name, :email
+
+  scope :have_email do
+    where(email: { '$exists' => true })
+  end
+
+  scope :start_with do |letter|
+    where(name: { '$regex' => "^#{letter}", '$options' => 'i' })
+  end
+end
+
+userRepository.query.start_with('b').to_a
+```
+
+Of course you can chain scopes.
+
+```ruby
+userRepository.query.start_with('b').have_email
+```
+
+The result of the scope is Enumerable, so you can apply the #each method and others (map, select etc).
+
+Inside the scopes you can use any methods supported by the driver (database client). In our case we use Origin (https://github.com/mongoid/origin) as a query builder for mongo.
+
+Also it's possible to use scopes to run the multi-row operations.
+
+```ruby
+userRepository.query.have_email.remove
+p userRepository.query.count # 0
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/alexei-lexx/rmodel/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/examples/user.rb

@@ -0,0 +1,48 @@
+require 'rmodel'
+
+Rmodel.setup do
+  client :default, { hosts: [ 'localhost' ], database: 'test' }
+end
+
+class User
+  attr_accessor :id, :name, :email
+
+  def initialize(name = nil, email = nil)
+    self.name = name
+    self.email = email
+  end
+end
+
+class UserRepository < Rmodel::Mongo::Repository
+  simple_factory User, :name, :email
+
+  scope :have_email do
+    where(email: { '$exists' => true })
+  end
+
+  scope :start_with do |letter|
+    where(name: { '$regex' => "^#{letter}", '$options' => 'i' })
+  end
+end
+
+userRepository = UserRepository.new
+userRepository.query.remove
+
+john = User.new('John', 'john@example.com')
+bill = User.new('Bill', 'bill@example.com')
+bob = User.new('Bob', 'bob@example.com')
+
+userRepository.insert(john)
+userRepository.insert(bill)
+userRepository.insert(bob)
+
+john.name = 'John Smith'
+userRepository.update(john)
+
+userRepository.remove(bob)
+
+p userRepository.find(john.id)
+p userRepository.find(bob.id)
+
+userRepository.query.have_email.remove
+p userRepository.query.count

data/lib/rmodel/errors.rb

@@ -0,0 +1,7 @@
+module Rmodel
+  class NotFound < StandardError
+    def initialize(repo_klass, criteria)
+      super("#{repo_klass.class.name} can't find an object by #{criteria}")
+    end
+  end
+end

data/lib/rmodel/mongo/repository.rb

@@ -0,0 +1,65 @@
+require 'mongo'
+require 'active_support/inflector'
+require 'rmodel/mongo/repository_ext/queryable'
+
+module Rmodel::Mongo
+  class Repository
+    include RepositoryExt::Queryable
+
+    def initialize
+      @client = Rmodel.setup.establish_mongo_client(self.class.client_name || :default) or
+                raise ArgumentError.new('Client driver is not setup')
+
+      @collection = self.class.setting_collection ||
+                    self.class.collection_by_convention or
+                    raise ArgumentError.new('Collection can not be guessed')
+
+      @factory = self.class.setting_factory or
+                 raise ArgumentError.new('Factory can not be guessed')
+    end
+
+    def find(id)
+      result = @client[@collection].find(_id: id).first
+      result && @factory.fromHash(result)
+    end
+
+    def find!(id)
+      find(id) or raise Rmodel::NotFound.new(self, { id: id })
+    end
+
+    def insert(object)
+      object.id ||= BSON::ObjectId.new
+      @client[@collection].insert_one(@factory.toHash(object, true))
+    end
+
+    def update(object)
+      @client[@collection].find(_id: object.id).update_one(@factory.toHash(object, false))
+    end
+
+    def remove(object)
+      @client[@collection].find(_id: object.id).delete_one
+    end
+
+    class << self
+      attr_reader :client_name, :setting_collection, :setting_factory
+
+      def client(name)
+        @client_name = name
+      end
+
+      def collection(name)
+        @setting_collection = name
+      end
+
+      def collection_by_convention
+        if name =~ /(.*)Repository$/
+          ActiveSupport::Inflector.tableize($1).to_sym
+        end
+      end
+
+      def simple_factory(klass, *attributes)
+        @setting_factory = SimpleFactory.new(klass, *attributes)
+      end
+    end
+  end
+end

data/lib/rmodel/mongo/repository_ext/query.rb

@@ -0,0 +1,34 @@
+require 'origin'
+
+module Rmodel::Mongo
+  module RepositoryExt
+    class Query
+      include Enumerable
+
+      class Queryable
+        include Origin::Queryable
+      end
+
+      def initialize(repo, queryable = nil)
+        @repo = repo
+        @queryable = queryable || Queryable.new
+      end
+
+      def each(&block)
+        @repo.find_by_query(@queryable.selector, @queryable.options).each(&block)
+        self
+      end
+
+      def remove
+        @repo.execute_query(@queryable.selector, @queryable.options).delete_many
+      end
+
+      def self.define_scope(name, &block)
+        define_method name do |*args|
+          new_queryable = @queryable.instance_exec(*args, &block)
+          self.class.new(@repo, new_queryable)
+        end
+      end
+    end
+  end
+end

data/lib/rmodel/mongo/repository_ext/queryable.rb

@@ -0,0 +1,34 @@
+require 'rmodel/mongo/repository_ext/query'
+
+module Rmodel::Mongo
+  module RepositoryExt
+    module Queryable
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def query
+        (self.class.query_klass ||= Class.new(Query)).new(self)
+      end
+
+      def find_by_query(selector, options)
+        execute_query(selector, options).map do |hash|
+          @factory.fromHash(hash)
+        end
+      end
+
+      def execute_query(selector, options)
+        @client[@collection].find(selector, options)
+      end
+
+      module ClassMethods
+        attr_accessor :query_klass
+
+        def scope(name, &block)
+          self.query_klass ||= Class.new(Query)
+          self.query_klass.define_scope(name, &block)
+        end
+      end
+    end
+  end
+end

data/lib/rmodel/mongo/setup.rb

@@ -0,0 +1,17 @@
+module Rmodel::Mongo
+  module Setup
+    def establish_mongo_client(name)
+      config = @clients_config[name]
+      if config
+        options = config.dup
+        options.delete :hosts
+
+        establish_client(name) { Mongo::Client.new(config[:hosts], options) }
+      end
+    end
+  end
+end
+
+class Rmodel::Setup
+  include Rmodel::Mongo::Setup
+end

data/lib/rmodel/mongo/simple_factory.rb

@@ -0,0 +1,28 @@
+module Rmodel::Mongo
+  class SimpleFactory
+    def initialize(klass, *attributes)
+      @klass = klass
+      @attributes = attributes
+    end
+
+    def fromHash(hash)
+      object = @klass.new
+      object.id = hash['_id']
+      @attributes.each do |attribute|
+        object.public_send "#{attribute}=", hash[attribute.to_s]
+      end
+      object
+    end
+
+    def toHash(object, id_included)
+      hash = {}
+      @attributes.each do |attribute|
+        hash[attribute.to_s] = object.public_send(attribute)
+      end
+      if id_included
+        hash['_id'] = object.id
+      end
+      hash
+    end
+  end
+end

data/lib/rmodel/setup.rb

@@ -0,0 +1,33 @@
+require 'singleton'
+
+module Rmodel
+  class Setup
+    include Singleton
+
+    def initialize
+      @clients_config = {}
+      @established_clients = {}
+    end
+
+    def client(name, config)
+      @clients_config[name] = config
+    end
+
+    def clear
+      @clients_config.clear
+    end
+
+    private
+
+    def establish_client(name)
+      @established_clients[name] ||= yield
+    end
+  end
+
+  def self.setup(&block)
+    if block
+      Setup.instance.instance_eval &block
+    end
+    Setup.instance
+  end
+end

data/lib/rmodel/version.rb

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

data/lib/rmodel.rb

@@ -0,0 +1,10 @@
+require 'rmodel/version'
+require 'rmodel/setup'
+require 'rmodel/errors'
+require 'rmodel/mongo/setup'
+require 'rmodel/mongo/simple_factory'
+require 'rmodel/mongo/repository'
+
+module Rmodel
+
+end

data/rmodel.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rmodel/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rmodel'
+  spec.version       = Rmodel::VERSION
+  spec.authors       = ['Alexei']
+  spec.email         = ['alexei.lexx@gmail.com']
+  spec.summary       = %q{Rmodel is an ORM library, which tends to follow the SOLID principles.}
+  spec.description   = %q{Rmodel is an ORM library, which tends to follow the SOLID principles.}
+  spec.homepage      = 'https://github.com/alexei-lexx/rmodel'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'mongo', '~> 2.1'
+  spec.add_dependency 'activesupport'
+  spec.add_dependency 'origin'
+
+  spec.add_development_dependency 'bundler', '~> 1.6'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec'
+end

data/spec/rmodel/mongo/repository_crud_spec.rb

@@ -0,0 +1,115 @@
+RSpec.describe Rmodel::Mongo::Repository do
+  include_context 'clean Mongo database'
+
+  before do
+    stub_const('User', Struct.new(:id, :name, :email))
+    stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository) {
+      simple_factory User, :name, :email
+    })
+    Rmodel.setup do
+      client :default, hosts: [ 'localhost' ], database: 'rmodel_test'
+    end
+  end
+
+  let(:factory) { Rmodel::Mongo::SimpleFactory.new(User, :name, :email) }
+  subject(:repo) { UserRepository.new }
+
+  describe '#find' do
+    context 'when an existent id is given' do
+      before do
+        mongo_session[:users].insert_one(_id: 1, name: 'John', email: 'john@example.com')
+      end
+
+      it 'returns the instance of correct type' do
+        expect(repo.find(1)).to be_an_instance_of User
+      end
+    end
+
+    context 'when a non-existent id is given' do
+      it 'returns nil' do
+        expect(repo.find(1)).to be_nil
+      end
+    end
+  end
+
+  describe '#find!' do
+    context 'when an existent id is given' do
+      before do
+        mongo_session[:users].insert_one(_id: 1, name: 'John', email: 'john@example.com')
+      end
+
+      it 'returns the right instance' do
+        expect(repo.find!(1)).not_to be_nil
+      end
+    end
+
+    context 'when a non-existent id is given' do
+      it 'raises the NotFound error' do
+        expect {
+          repo.find!(1)
+        }.to raise_error Rmodel::NotFound
+      end
+    end
+  end
+
+  describe '#insert' do
+    context 'when the id is not provided' do
+      let(:user) { User.new(nil, 'John', 'john@example.com') }
+
+      it 'sets the id before insert' do
+        repo.insert(user)
+        expect(user.id).not_to be_nil
+      end
+
+      it 'persists the object' do
+        repo.insert(user)
+        found = mongo_session[:users].find(name: 'John', email: 'john@example.com').count
+        expect(found).to eq 1
+      end
+    end
+
+    context 'when the id is provided' do
+      let(:user) { User.new(1, 'John', 'john@example.com') }
+
+      it 'uses the existent id' do
+        repo.insert(user)
+        expect(user.id).to eq 1
+      end
+    end
+
+    context 'when the given id already exists' do
+      let(:user) { User.new(nil, 'John', 'john@example.com') }
+      before { repo.insert(user) }
+
+      it 'raises the error' do
+        expect { repo.insert(user) }.to raise_error Mongo::Error::OperationFailure
+      end
+    end
+  end
+
+  describe '#update' do
+    let(:user) { User.new(nil, 'John', 'john@example.com') }
+
+    before do
+      repo.insert(user)
+      user.name = 'John Smith'
+    end
+
+    it 'updates the record' do
+      repo.update(user)
+      found = mongo_session[:users].find(name: 'John Smith').count
+      expect(found).to eq 1
+    end
+  end
+
+  describe '#remove' do
+    let(:user) { User.new(nil, 'John', 'john@example.com') }
+    before { repo.insert(user) }
+
+    it 'removes the record' do
+      repo.remove(user)
+      found = mongo_session[:users].find(name: 'John').count
+      expect(found).to eq 0
+    end
+  end
+end

data/spec/rmodel/mongo/repository_initialize_spec.rb

@@ -0,0 +1,140 @@
+RSpec.describe Rmodel::Mongo::Repository do
+  before do
+    Rmodel.setup.clear
+    stub_const('User', Struct.new(:id, :name, :email))
+  end
+
+  subject { UserRepository.new }
+
+  describe '.client(name)' do
+    before do
+      Rmodel::Setup.send :public, :client
+    end
+    context 'when it is called with an existent name' do
+      before do
+        Rmodel.setup do
+          client :mongo, { hosts: [ 'localhost' ] }
+        end
+
+        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository) {
+          client :mongo
+          simple_factory User, :name, :email
+          attr_reader :client
+        })
+      end
+
+      it 'sets the appropriate #client' do
+        expect(subject.client).to be_an_instance_of Mongo::Client
+      end
+    end
+
+    context 'when it is called with a non-existent name' do
+      before do
+        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository) {
+          client :mongo
+          simple_factory User, :name, :email
+          attr_reader :client
+        })
+      end
+
+      it 'makes #client raise the ArgumentError' do
+        expect { subject.client }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when it is not called' do
+      before do
+        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository) {
+          simple_factory User, :name, :email
+          attr_reader :client
+        })
+      end
+
+      context 'when the :default client is set' do
+        before do
+          Rmodel.setup do
+            client :default, { hosts: [ 'localhost' ] }
+          end
+        end
+
+        it 'sets #client to be default' do
+          expect(subject.client).to be_an_instance_of Mongo::Client
+        end
+      end
+
+      context 'when the :default client is not set' do
+        it 'makes #client raise the ArgumentError' do
+          expect { subject.client }.to raise_error ArgumentError
+        end
+      end
+    end
+  end
+
+  describe '.collection(name)' do
+    before do
+      Rmodel.setup do
+        client :default, { hosts: [ 'localhost' ] }
+      end
+    end
+
+    context 'when the :people collection is given' do
+      before do
+        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository) {
+          collection :people
+          simple_factory User, :name, :email
+          attr_reader :collection
+        })
+      end
+
+      it 'uses the :people' do
+        expect(subject.collection).to eq :people
+      end
+    end
+
+    context 'when no collection is given' do
+      before do
+        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository) {
+          simple_factory User, :name, :email
+          attr_reader :collection
+        })
+      end
+
+      it 'gets the right name by convention' do
+        expect(subject.collection).to eq :users
+      end
+    end
+  end
+
+  describe '.simple_factory(klass, attribute1, attribute2, ...)' do
+    before do
+      Rmodel.setup do
+        client :default, { hosts: [ 'localhost' ] }
+      end
+    end
+
+    context 'when it is called' do
+      before do
+        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository) {
+          simple_factory User, :name, :email
+          attr_reader :factory
+        })
+      end
+
+      it 'sets the appropriate #factory' do
+        expect(subject.factory).to be_an_instance_of Rmodel::Mongo::SimpleFactory
+      end
+    end
+
+    context 'when it is not called' do
+      before do
+        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository))
+      end
+
+      it 'make #initialize raise an error' do
+        expect {
+          UserRepository.new
+        }.to raise_error ArgumentError
+      end
+    end
+  end
+end

data/spec/rmodel/mongo/repository_queryable_spec.rb

@@ -0,0 +1,107 @@
+RSpec.describe Rmodel::Mongo::Repository do
+  include_context 'clean Mongo database'
+
+  before do
+    Rmodel.setup do
+      client :default, hosts: [ 'localhost' ], database: 'rmodel_test'
+    end
+    stub_const('Thing', Struct.new(:id, :a, :b))
+    stub_const('ThingRepository', Class.new(Rmodel::Mongo::Repository) {
+      simple_factory Thing, :a, :b
+    })
+  end
+
+  let(:repo) { ThingRepository.new }
+
+  before do
+    repo.insert(Thing.new(nil, 2, 3))
+    repo.insert(Thing.new(nil, 2, 4))
+    repo.insert(Thing.new(nil, 5, 6))
+  end
+
+  describe '.scope' do
+    context 'when a scope w/o arguments is defined' do
+      before do
+        ThingRepository.class_eval do
+          scope :a_equals_2 do
+            where(a: 2)
+          end
+        end
+      end
+
+      it 'works!' do
+        expect(repo.query.a_equals_2.count).to eq 2
+      end
+
+      it 'returns an array of instances of the appropriate class' do
+        expect(repo.query.a_equals_2.first).to be_an_instance_of Thing
+      end
+    end
+
+    context 'when a scope w/ arguments is defined' do
+      before do
+        ThingRepository.class_eval do
+          scope :a_equals do |n|
+            where(a: n)
+          end
+        end
+      end
+
+      it 'works!' do
+        expect(repo.query.a_equals(2).count).to eq 2
+      end
+    end
+
+    context 'when two scopes are defined and chained' do
+      before do
+        ThingRepository.class_eval do
+          scope :a_equals do |n|
+            where(a: n)
+          end
+
+          scope :b_equals do |n|
+            where(b: n)
+          end
+        end
+      end
+
+      it 'works!' do
+        expect(repo.query.a_equals(2).b_equals(4).count).to eq 1
+      end
+    end
+
+    context 'when an unknown scope is used' do
+      it 'raises the NoMethodError' do
+        expect {
+          repo.query.something
+        }.to raise_error NoMethodError
+      end
+    end
+  end
+
+  describe '.query' do
+    describe '#remove' do
+      context 'when no scope is given' do
+        it 'removes all objects' do
+          repo.query.remove
+          expect(repo.query.count).to eq 0
+        end
+      end
+
+      context 'when the scope filters 2 objects from 3' do
+        before do
+          ThingRepository.class_eval do
+            scope :a_equals_2 do
+              where(a: 2)
+            end
+          end
+        end
+
+        it 'removes 2 objects' do
+          repo.query.a_equals_2.remove
+          expect(repo.query.count).to eq 1
+        end
+      end
+    end
+  end
+end

data/spec/rmodel/mongo/simple_factory_spec.rb

@@ -0,0 +1,55 @@
+RSpec.describe Rmodel::Mongo::SimpleFactory do
+  context 'when the User(id, name, email) class is defined' do
+    before { stub_const('User', Struct.new(:id, :name, :email)) }
+
+    subject(:factory) { Rmodel::Mongo::SimpleFactory.new(User, :name, :email) }
+
+    describe '#fromHash' do
+      context 'when the hash with _id, name and email is given' do
+        let(:hash) { { '_id' => 1, 'name' => 'John', 'email' => 'john@example.com' } }
+        let(:result) { factory.fromHash(hash) }
+
+        it 'returns an instance of User' do
+          expect(result).to be_an_instance_of User
+        end
+
+        it 'sets the attributes correctly' do
+          expect(result.name).to eq 'John'
+          expect(result.email).to eq 'john@example.com'
+        end
+
+        it 'sets the User#id correctly' do
+          expect(result.id).to eq 1
+        end
+      end
+    end
+
+    describe '#toHash' do
+      let(:user) { User.new(1, 'John', 'john@example.com') }
+      context 'when id_included is false' do
+        let(:result) { factory.toHash(user, false) }
+
+        it 'returns an instance of Hash' do
+          expect(result).to be_an_instance_of Hash
+        end
+
+        it 'sets the keys correctly' do
+          expect(result['name']).to eq 'John'
+          expect(result['email']).to eq 'john@example.com'
+        end
+
+        it 'has no the "_id" key' do
+          expect(result.has_key?('_id')).to be false
+        end
+      end
+
+      context 'when id_included is true' do
+        let(:result) { factory.toHash(user, true) }
+
+        it 'sets the "_id" key' do
+          expect(result['_id']).to eq 1
+        end
+      end
+    end
+  end
+end

data/spec/rmodel/setup_spec.rb

@@ -0,0 +1,54 @@
+RSpec.describe Rmodel do
+  describe '.setup' do
+    before { Rmodel::Setup.instance.clear }
+    context 'when no block is passed' do
+      it 'returns Rmodel::Setup.instance' do
+        expect(Rmodel.setup).to equal Rmodel::Setup.instance
+      end
+    end
+
+    context 'when the block is passed' do
+      let(:clients_config) { Rmodel::Setup.instance.instance_variable_get('@clients_config') }
+
+      it 'returns Rmodel::Setup.instance' do
+        expect(Rmodel.setup).to equal Rmodel::Setup.instance
+      end
+
+      it 'runs setup methods within the block' do
+        Rmodel.setup do
+          client :default, {}
+        end
+        expect(clients_config[:default]).to eq({})
+      end
+    end
+  end
+
+  describe Rmodel::Setup do
+    subject { Rmodel::Setup.instance }
+    let(:clients_config) { subject.instance_variable_get('@clients_config') }
+
+    describe '#new' do
+      it 'raises the NoMethodError' do
+        expect { Rmodel::Setup.new }.to raise_error NoMethodError
+      end
+    end
+
+    describe '#client(name, config)' do
+      it 'makes config available via #clients[name]' do
+        subject.client :default, { host: 'localhost' }
+        expect(clients_config[:default]).to eq( host: 'localhost' )
+      end
+    end
+
+    describe '#clear' do
+      context 'when one client is set' do
+        before { subject.client :default, { host: 'localhost' } }
+
+        it 'removes all clients' do
+          subject.clear
+          expect(clients_config).to be_empty
+        end
+      end
+    end
+  end
+end

data/spec/shared/clean_moped.rb

@@ -0,0 +1,10 @@
+RSpec.shared_context 'clean Mongo database' do
+  let(:mongo_session) { Mongo::Client.new([ '127.0.0.1:27017' ], database: 'rmodel_test') }
+
+  before(:all) do
+    Mongo::Logger.logger.level = Logger::ERROR
+    mongo_session = Mongo::Client.new([ '127.0.0.1:27017' ], database: 'rmodel_test')
+    mongo_session.database.drop
+  end
+  after { mongo_session.database.drop }
+end

data/spec/spec_helper.rb

@@ -0,0 +1,100 @@
+require 'rmodel'
+
+Dir[File.dirname(__FILE__) + '/shared/**/*.rb'].each { |f| require f }
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause
+# this file to always be loaded, without a need to explicitly require it in any
+# files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files that actually need
+# it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    #     be_bigger_than(2).and_smaller_than(4).description
+    #     # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #     # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+=end
+end

metadata

@@ -0,0 +1,160 @@
+--- !ruby/object:Gem::Specification
+name: rmodel
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alexei
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.1'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: origin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Rmodel is an ORM library, which tends to follow the SOLID principles.
+email:
+- alexei.lexx@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- examples/user.rb
+- lib/rmodel.rb
+- lib/rmodel/errors.rb
+- lib/rmodel/mongo/repository.rb
+- lib/rmodel/mongo/repository_ext/query.rb
+- lib/rmodel/mongo/repository_ext/queryable.rb
+- lib/rmodel/mongo/setup.rb
+- lib/rmodel/mongo/simple_factory.rb
+- lib/rmodel/setup.rb
+- lib/rmodel/version.rb
+- rmodel.gemspec
+- spec/rmodel/mongo/repository_crud_spec.rb
+- spec/rmodel/mongo/repository_initialize_spec.rb
+- spec/rmodel/mongo/repository_queryable_spec.rb
+- spec/rmodel/mongo/simple_factory_spec.rb
+- spec/rmodel/setup_spec.rb
+- spec/shared/clean_moped.rb
+- spec/spec_helper.rb
+homepage: https://github.com/alexei-lexx/rmodel
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: Rmodel is an ORM library, which tends to follow the SOLID principles.
+test_files:
+- spec/rmodel/mongo/repository_crud_spec.rb
+- spec/rmodel/mongo/repository_initialize_spec.rb
+- spec/rmodel/mongo/repository_queryable_spec.rb
+- spec/rmodel/mongo/simple_factory_spec.rb
+- spec/rmodel/setup_spec.rb
+- spec/shared/clean_moped.rb
+- spec/spec_helper.rb