rmodel 0.2.2.pre.dev → 0.3.0.pre.dev

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1b2245246230da601f1327a85f31eb1620b845d0
-  data.tar.gz: fba4de0431ac5f5bb38db8c946dcb789e6fc919d
+  metadata.gz: 790c3d9b1e832db25110443277f43ecc7dc8c195
+  data.tar.gz: 075fb90b667ce3efc49e772366039173439c3941
 SHA512:
-  metadata.gz: 83e9ca4326098fae9e620cd853d9f05558937b81813c4f85f9b15d06640b6b98605dd397911df9c6c171660a8cb28d53390fbcec643ce74f575e70aef74e88d3
-  data.tar.gz: 13e959f27b6654e2c6658689e2f00c13a1789047a65c1aaff0d76bb86f61805ab3d54999991a70a8b5c68171af79f10a7bb670e8e7722236d25086f4f6057f11
+  metadata.gz: c70ec6448d74876b0fc8e82598e9ba695d03b6d57321925b66db79928789c6c89a09c3d9d87f6f680b9cc60abf77a185eb33c139782e21d4c4744f3c998b59f5
+  data.tar.gz: f6137976d4574443696e365ad4165d5bff58cd2960174776c7baafe4faa6fd7c77b286194617c49b9c967d3bdf2ae2ef55205723985c081fbe13894272ad2615

data/.gitignore

@@ -20,3 +20,4 @@ tmp
 *.o
 *.a
 mkmf.log
+rmodel_test.sqlite3

data/README.md

@@ -9,10 +9,11 @@
   * [Timestamps](#timestamps)
   * [Sugar methods](#sugar-methods)
   * [Advanced creation of repository](#advanced-creation-of-repository)
+  * [SQL repository](#sql-repository)
 
 Rmodel is an ORM library, which tends to follow the SOLID principles.
 
-**Currently works with MongoDB only.**
+**Currently works with MongoDB and SQL databases supported by Sequel.**
 
 The main thoughts behind it are:
 
@@ -228,6 +229,58 @@ repo.find(1)
 
 The `factory` is an object, which has 2 methods: `#fromHash(hash)` and `#toHash(object)`.
 
+### SQL repository
+
+SQL amenities is based on the Sequel gem (http://sequel.jeremyevans.net/).
+So the big range of SQL databases is supported.
+
+> Sequel currently has adapters for ADO, Amalgalite, CUBRID, DataObjects, IBM_DB, JDBC, MySQL, Mysql2, ODBC, Oracle, PostgreSQL, SQLAnywhere, SQLite3, Swift, and TinyTDS.
+
+Below you can the the example how to setup Rmodel for any supported SQL database.
+
+```ruby
+require 'rmodel'
+
+Rmodel.setup do
+  client :default, { adapter: 'sqlite', database: 'rmodel_test.sqlite3' }
+end
+
+client = Rmodel.setup.establish_sequel_client(:default)
+client.drop_table? :things
+client.create_table :things do
+  primary_key :id
+  String :name
+  Float :price
+end
+
+class Thing
+  attr_accessor :id, :name, :price
+
+  def initialize(name = nil, price = nil)
+    self.name = name
+    self.price = price
+  end
+end
+
+class ThingRepository < Rmodel::Sequel::Repository
+  simple_factory Thing, :name, :price
+
+  scope :worth_more_than do |amount|
+    # use Sequel dataset filtering http://sequel.jeremyevans.net/rdoc/files/doc/dataset_filtering_rdoc.html
+    where { price >= amount }
+  end
+end
+
+repo = ThingRepository.new
+repo.insert Thing.new('iPod', 200)
+repo.insert Thing.new('iPhone', 300)
+repo.insert Thing.new('iPad', 500)
+
+p repo.query.count # 3
+p repo.query.worth_more_than(400).count # 1
+p repo.query.worth_more_than(400).to_sql
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/alexei-lexx/rmodel/fork )

data/examples/sql_repository.rb

@@ -0,0 +1,42 @@
+require 'rmodel'
+
+Rmodel.setup do
+  # see more examples of connection options
+  # http://sequel.jeremyevans.net/rdoc/files/doc/opening_databases_rdoc.html#label-Passing+a+block+to+either+method
+  client :default, { adapter: 'sqlite', database: 'rmodel_test.sqlite3' }
+end
+
+client = Rmodel.setup.establish_sequel_client(:default)
+client.drop_table? :things
+client.create_table :things do
+  primary_key :id
+  String :name
+  Float :price
+end
+
+class Thing
+  attr_accessor :id, :name, :price
+
+  def initialize(name = nil, price = nil)
+    self.name = name
+    self.price = price
+  end
+end
+
+class ThingRepository < Rmodel::Sequel::Repository
+  simple_factory Thing, :name, :price
+
+  scope :worth_more_than do |amount|
+    # use Sequel dataset filtering http://sequel.jeremyevans.net/rdoc/files/doc/dataset_filtering_rdoc.html
+    where { price >= amount }
+  end
+end
+
+repo = ThingRepository.new
+repo.insert Thing.new('iPod', 200)
+repo.insert Thing.new('iPhone', 300)
+repo.insert Thing.new('iPad', 500)
+
+p repo.query.count # 3
+p repo.query.worth_more_than(400).count # 1
+p repo.query.worth_more_than(400).to_sql

data/lib/rmodel/sequel/repository.rb

@@ -0,0 +1,61 @@
+require 'sequel'
+require 'rmodel/base/repository'
+require 'rmodel/sequel/repository_ext/queryable'
+
+module Rmodel::Sequel
+  class Repository < Rmodel::Base::Repository
+    include RepositoryExt::Queryable
+
+    def initialize(client = nil, table = nil, factory = nil)
+      @client = client || Rmodel.setup.establish_sequel_client(self.class.client_name || :default) or
+                raise ArgumentError.new('Client driver is not setup')
+
+      @table = table || self.class.setting_table ||
+               self.class.table_by_convention or
+               raise ArgumentError.new('Table can not be guessed')
+
+      @factory = factory || self.class.setting_factory or
+                 raise ArgumentError.new('Factory can not be guessed')
+    end
+
+    def find(id)
+      result = @client[@table].where(id: id).first
+      result && @factory.fromHash(result)
+    end
+
+    def insert(object)
+      id = @client[@table].insert(@factory.toHash(object, true))
+      object.id ||= id
+    end
+
+    def update(object)
+      @client[@table].where(id: object.id).update(@factory.toHash(object, false))
+    end
+
+    def remove(object)
+      @client[@table].where(id: object.id).delete
+    end
+
+    class << self
+      attr_reader :client_name, :setting_table, :setting_factory
+
+      def client(name)
+        @client_name = name
+      end
+
+      def table(name)
+        @setting_table = name
+      end
+
+      def table_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/sequel/repository_ext/query.rb

@@ -0,0 +1,34 @@
+require 'origin'
+
+module Rmodel::Sequel
+  module RepositoryExt
+    class Query
+      include Enumerable
+
+      def initialize(repo, dataset)
+        @repo = repo
+        @dataset = dataset
+      end
+
+      def each(&block)
+        @repo.find_by_query(@dataset).each(&block)
+        self
+      end
+
+      def remove
+        @dataset.delete
+      end
+
+      def to_sql
+        @dataset.sql
+      end
+
+      def self.define_scope(name, &block)
+        define_method name do |*args|
+          new_dataset = @dataset.instance_exec(*args, &block)
+          self.class.new(@repo, new_dataset)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require 'rmodel/sequel/repository_ext/query'
+
+module Rmodel::Sequel
+  module RepositoryExt
+    module Queryable
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def query
+        (self.class.query_klass ||= Class.new(Query)).new(self, @client[@table])
+      end
+
+      def find_by_query(dataset)
+        dataset.map do |hash|
+          @factory.fromHash(hash)
+        end
+      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/sequel/setup.rb

@@ -0,0 +1,12 @@
+module Rmodel::Sequel
+  module Setup
+    def establish_sequel_client(name)
+      config = @clients_config[name]
+      config && establish_client(name) { Sequel.connect(config) }
+    end
+  end
+end
+
+class Rmodel::Setup
+  include Rmodel::Sequel::Setup
+end

data/lib/rmodel/sequel/simple_factory.rb

@@ -0,0 +1,28 @@
+module Rmodel::Sequel
+  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_sym]
+      end
+      object
+    end
+
+    def toHash(object, id_included)
+      hash = {}
+      @attributes.each do |attribute|
+        hash[attribute.to_sym] = object.public_send(attribute)
+      end
+      if id_included
+        hash[:id] = object.id
+      end
+      hash
+    end
+  end
+end

data/lib/rmodel/setup.rb

@@ -15,6 +15,7 @@ module Rmodel
 
     def clear
       @clients_config.clear
+      @established_clients.clear
     end
 
     private

data/lib/rmodel/version.rb

@@ -1,3 +1,3 @@
 module Rmodel
-  VERSION = "0.2.2-dev"
+  VERSION = "0.3.0-dev"
 end

data/lib/rmodel.rb

@@ -4,6 +4,9 @@ require 'rmodel/errors'
 require 'rmodel/mongo/setup'
 require 'rmodel/mongo/simple_factory'
 require 'rmodel/mongo/repository'
+require 'rmodel/sequel/setup'
+require 'rmodel/sequel/simple_factory'
+require 'rmodel/sequel/repository'
 
 module Rmodel
 

data/rmodel.gemspec

@@ -21,10 +21,12 @@ Gem::Specification.new do |spec|
   spec.add_dependency 'mongo', '~> 2.1'
   spec.add_dependency 'activesupport'
   spec.add_dependency 'origin'
+  spec.add_dependency 'sequel'
 
   spec.add_development_dependency 'bundler', '~> 1.6'
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'sqlite3'
 
   spec.required_ruby_version = '>= 2.0.0'
 end

data/spec/rmodel/mongo/repository_ext/queryable_spec.rb

@@ -1,5 +1,5 @@
 RSpec.describe Rmodel::Mongo::Repository do
-  include_context 'clean Mongo database'
+  include_context 'clean mongo database'
 
   before do
     stub_const('Thing', Struct.new(:id, :a, :b))

data/spec/rmodel/mongo/repository_spec.rb

@@ -0,0 +1,50 @@
+RSpec.describe Rmodel::Mongo::Repository do
+  it_behaves_like 'repository crud' do
+    include_context 'clean mongo database'
+
+    before do
+      stub_const('ThingRepository', Class.new(Rmodel::Mongo::Repository))
+    end
+
+    let(:factory) { Rmodel::Mongo::SimpleFactory.new(Thing, :name) }
+    subject { ThingRepository.new(mongo_session, :things, factory) }
+    let(:unique_constraint_error) { Mongo::Error::OperationFailure }
+
+    def insert_record(id, columns)
+      record = columns.dup
+      record['_id'] = id
+      mongo_session[:things].insert_one(record)
+    end
+  end
+
+  it_behaves_like 'sugarable repository' do
+    include_context 'clean mongo database'
+
+    before do
+      stub_const('ThingRepository', Class.new(Rmodel::Mongo::Repository))
+    end
+
+    subject do
+      factory = Rmodel::Mongo::SimpleFactory.new(Thing, :name)
+      ThingRepository.new(mongo_session, :things, factory)
+    end
+  end
+
+  it_behaves_like 'timestampable repository' do
+    include_context 'clean mongo database'
+
+    before do
+      stub_const('ThingRepository', Class.new(Rmodel::Mongo::Repository))
+    end
+
+    let(:repo_w_timestamps) do
+      factory = Rmodel::Mongo::SimpleFactory.new(Thing, :name, :created_at, :updated_at)
+      ThingRepository.new(mongo_session, :things, factory)
+    end
+
+    let(:repo_wo_timestamps) do
+      factory = Rmodel::Mongo::SimpleFactory.new(Thing, :name)
+      ThingRepository.new(mongo_session, :things, factory)
+    end
+  end
+end

data/spec/rmodel/sequel/repository_ext/queryable_spec.rb

@@ -0,0 +1,114 @@
+RSpec.describe Rmodel::Sequel::Repository do
+  include_context 'clean sequel database'
+
+  before do
+    create_database
+    stub_const('Thing', Struct.new(:id, :a, :b))
+    stub_const('ThingRepository', Class.new(Rmodel::Sequel::Repository))
+  end
+
+  subject do
+    factory = Rmodel::Sequel::SimpleFactory.new(Thing, :a, :b)
+    ThingRepository.new(sequel_conn, :things, factory)
+  end
+
+  before do
+    subject.insert(Thing.new(nil, 2, 3))
+    subject.insert(Thing.new(nil, 2, 4))
+    subject.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(subject.query.a_equals_2.count).to eq 2
+      end
+
+      it 'returns an array of instances of the appropriate class' do
+        expect(subject.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(subject.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(subject.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 {
+          subject.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
+          subject.query.remove
+          expect(subject.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
+          subject.query.a_equals_2.remove
+          expect(subject.query.count).to eq 1
+        end
+      end
+    end
+  end
+
+  def create_database
+    sequel_conn.create_table(:things) do
+      primary_key :id
+      Integer :a
+      Integer :b
+    end
+  end
+end

data/spec/rmodel/sequel/repository_initialize_spec.rb

@@ -0,0 +1,118 @@
+RSpec.describe Rmodel::Sequel::Repository do
+  before do
+    stub_const('Thing', Struct.new(:id, :name))
+    stub_const('ThingRepository', Class.new(Rmodel::Sequel::Repository))
+    ThingRepository.send :attr_reader, :client, :table, :factory
+  end
+  let(:factory) { Rmodel::Sequel::SimpleFactory.new(Thing, :name) }
+
+  describe '.client(name)' do
+    conn_options = { adapter: 'sqlite', database: 'rmodel_test.sqlite3' }
+
+    subject { ThingRepository.new(nil, :things, factory) }
+
+    context 'when it is called with an existent name' do
+      before do
+        Rmodel.setup do
+          client :not_default, conn_options
+        end
+
+        ThingRepository.class_eval do
+          client :not_default
+        end
+      end
+      after { Rmodel::setup.clear }
+
+      it 'sets the appropriate #client' do
+        expect(subject.client).to be_a_kind_of Sequel::Database
+      end
+    end
+
+    context 'when it is called with a non-existent name' do
+      before do
+        ThingRepository.class_eval do
+          client :not_default
+        end
+      end
+
+      it 'makes #initialize raise the ArgumentError' do
+        expect { subject }.to raise_error ArgumentError
+      end
+    end
+
+    context 'when it is not called' do
+      context 'when the :default client is set' do
+        before do
+          Rmodel.setup do
+            client :default, conn_options
+          end
+        end
+        after { Rmodel::setup.clear }
+
+        it 'sets #client to be default' do
+          expect(subject.client).to be_a_kind_of Sequel::Database
+        end
+      end
+
+      context 'when the :default client is not set' do
+        it 'makes #initialize raise the ArgumentError' do
+          expect { subject }.to raise_error ArgumentError
+        end
+      end
+    end
+  end
+
+  describe '.table(name)' do
+    subject { ThingRepository.new(Object.new, nil, factory) }
+
+    context 'when the :people table is given' do
+      before do
+        ThingRepository.class_eval do
+          table :people
+        end
+      end
+
+      it 'uses the :people' do
+        expect(subject.table).to eq :people
+      end
+    end
+
+    context 'when no table is given' do
+      it 'gets the right name by convention' do
+        expect(subject.table).to eq :things
+      end
+    end
+  end
+
+  describe '.simple_factory(klass, attribute1, attribute2, ...)' do
+    subject { ThingRepository.new(Object.new, :things) }
+
+    context 'when it is called' do
+      before do
+        ThingRepository.class_eval do
+          simple_factory Thing, :name, :email
+        end
+      end
+
+      it 'sets the appropriate #factory' do
+        expect(subject.factory).to be_an_instance_of Rmodel::Sequel::SimpleFactory
+      end
+    end
+
+    context 'when it is not called' do
+      it 'make #initialize raise an error' do
+        expect { subject }.to raise_error ArgumentError
+      end
+    end
+  end
+
+  describe '#initialize(client, collection, factory)' do
+    context 'when all constructor arguments are passed' do
+      it 'works!' do
+        expect {
+          ThingRepository.new(Object.new, :users, factory)
+        }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/rmodel/sequel/repository_spec.rb

@@ -0,0 +1,64 @@
+RSpec.describe Rmodel::Sequel::Repository do
+  it_behaves_like 'repository crud' do
+    include_examples 'clean sequel database'
+
+    before do
+      create_database
+      stub_const('ThingRepository', Class.new(Rmodel::Sequel::Repository))
+    end
+
+    let(:factory) { Rmodel::Sequel::SimpleFactory.new(Thing, :name) }
+    subject { ThingRepository.new(sequel_conn, :things, factory) }
+    let(:unique_constraint_error) { Sequel::UniqueConstraintViolation }
+
+    def insert_record(id, columns)
+      record = columns.dup
+      record[:id] = id
+      sequel_conn[:things].insert(record)
+    end
+  end
+
+  it_behaves_like 'sugarable repository' do
+    include_examples 'clean sequel database'
+
+    before do
+      create_database
+      stub_const('ThingRepository', Class.new(Rmodel::Sequel::Repository))
+    end
+
+    subject do
+      factory = Rmodel::Sequel::SimpleFactory.new(Thing, :name)
+      ThingRepository.new(sequel_conn, :things, factory)
+    end
+  end
+
+  it_behaves_like 'timestampable repository' do
+    include_examples 'clean sequel database'
+
+    before do
+      create_database(true)
+      stub_const('ThingRepository', Class.new(Rmodel::Sequel::Repository))
+    end
+
+    let(:repo_w_timestamps) do
+      factory = Rmodel::Sequel::SimpleFactory.new(Thing, :name, :created_at, :updated_at)
+      ThingRepository.new(sequel_conn, :things, factory)
+    end
+
+    let(:repo_wo_timestamps) do
+      factory = Rmodel::Sequel::SimpleFactory.new(Thing, :name)
+      ThingRepository.new(sequel_conn, :things, factory)
+    end
+  end
+
+  def create_database(timestamps = false)
+    sequel_conn.create_table(:things) do
+      primary_key :id
+      String :name
+      if timestamps
+        Time :created_at
+        Time :updated_at
+      end
+    end
+  end
+end

data/spec/rmodel/sequel/simple_factory_spec.rb

@@ -0,0 +1,55 @@
+RSpec.describe Rmodel::Sequel::SimpleFactory do
+  context 'when the User(id, name, email) class is defined' do
+    before { stub_const('User', Struct.new(:id, :name, :email)) }
+
+    subject { described_class.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) { subject.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) { subject.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) { subject.toHash(user, true) }
+
+        it 'sets the "id" key' do
+          expect(result[:id]).to eq 1
+        end
+      end
+    end
+  end
+end

data/spec/shared/clean_moped.rb

@@ -1,4 +1,4 @@
-RSpec.shared_context 'clean Mongo database' do
+RSpec.shared_context 'clean mongo database' do
   let(:mongo_session) { Mongo::Client.new([ '127.0.0.1:27017' ], database: 'rmodel_test') }
 
   before(:all) do

data/spec/shared/clean_sequel.rb

@@ -0,0 +1,11 @@
+RSpec.shared_context 'clean sequel database' do
+  let(:sequel_conn) { Sequel.connect(adapter: 'sqlite', database: 'rmodel_test.sqlite3') }
+
+  before(:all) do
+    Mongo::Logger.logger.level = Logger::ERROR
+    sequel_conn = Sequel.sqlite('rmodel_test.sqlite3')
+    sequel_conn.drop_table?(:users, :things)
+  end
+
+  after { sequel_conn.drop_table?(:users, :things) }
+end

data/spec/shared/repository_ext/crud.rb

@@ -0,0 +1,83 @@
+RSpec.shared_examples 'repository crud' do
+  before do
+    stub_const('Thing', Struct.new(:id, :name))
+  end
+
+  describe '#find' do
+    before { insert_record(1, name: 'chair') }
+
+    context 'when an existent id is given' do
+      it 'returns the instance of correct type' do
+        expect(subject.find(1)).to be_an_instance_of Thing
+      end
+
+      it 'returns the correct attributes' do
+        expect(subject.find(1).name).to eq 'chair'
+      end
+    end
+
+    context 'when a non-existent id is given' do
+      it 'returns nil' do
+        expect(subject.find(2)).to be_nil
+      end
+    end
+  end
+
+  describe '#insert' do
+    context 'when the id is not provided' do
+      let(:thing) { Thing.new(nil, 'chair') }
+
+      it 'sets the id before insert' do
+        subject.insert(thing)
+        expect(thing.id).not_to be_nil
+      end
+
+      it 'persists the object' do
+        subject.insert(thing)
+        expect(subject.find(thing.id).name).to eq 'chair'
+      end
+    end
+
+    context 'when the id is provided' do
+      let(:thing) { Thing.new(1000, 'chair') }
+
+      it 'uses the existent id' do
+        subject.insert(thing)
+        expect(thing.id).to eq 1000
+      end
+    end
+
+    context 'when the given id already exists' do
+      let(:thing) { Thing.new }
+      before { subject.insert(thing) }
+
+      it 'raises the error' do
+        expect { subject.insert(thing) }.to raise_error unique_constraint_error
+      end
+    end
+  end
+
+  describe '#update' do
+    let(:thing) { Thing.new(nil) }
+
+    before do
+      subject.insert(thing)
+      thing.name = 'chair'
+    end
+
+    it 'updates the record' do
+      subject.update(thing)
+      expect(subject.find(thing.id).name).to eq 'chair'
+    end
+  end
+
+  describe '#remove' do
+    let(:thing) { Thing.new }
+    before { subject.insert(thing) }
+
+    it 'removes the record' do
+      subject.remove(thing)
+      expect(subject.find(thing.id)).to be_nil
+    end
+  end
+end

data/spec/shared/repository_ext/sugarable.rb

@@ -1,45 +1,43 @@
 RSpec.shared_examples 'sugarable repository' do
-  describe Rmodel::Base::RepositoryExt::Sugarable do
-    before do
-      stub_const('Thing', Struct.new(:id, :name))
-    end
+  before do
+    stub_const('Thing', Struct.new(:id, :name))
+  end
 
-    describe '#find!' do
-      context 'when an existent id is given' do
-        before { subject.insert(Thing.new(1)) }
+  describe '#find!' do
+    context 'when an existent id is given' do
+      before { subject.insert(Thing.new(1)) }
 
-        it 'returns the right instance' do
-          expect(subject.find!(1)).not_to be_nil
-        end
+      it 'returns the right instance' do
+        expect(subject.find!(1)).not_to be_nil
       end
+    end
 
-      context 'when a non-existent id is given' do
-        it 'raises NotFound' do
-          expect {
-            subject.find!(1)
-          }.to raise_error Rmodel::NotFound
-        end
+    context 'when a non-existent id is given' do
+      it 'raises NotFound' do
+        expect {
+          subject.find!(1)
+        }.to raise_error Rmodel::NotFound
       end
     end
+  end
 
-    describe 'save' do
-      let(:thing) { Thing.new }
+  describe 'save' do
+    let(:thing) { Thing.new }
 
-      context 'when a new object is given' do
-        it 'gets inserted' do
-          subject.save(thing)
-          expect(subject.find(thing.id)).not_to be_nil
-        end
+    context 'when a new object is given' do
+      it 'gets inserted' do
+        subject.save(thing)
+        expect(subject.find(thing.id)).not_to be_nil
       end
+    end
 
-      context 'when an existent object is given' do
-        before { subject.insert(thing) }
+    context 'when an existent object is given' do
+      before { subject.insert(thing) }
 
-        it 'gets updated' do
-          thing.name = 'chair'
-          subject.save(thing)
-          expect(subject.find(thing.id).name).to eq 'chair'
-        end
+      it 'gets updated' do
+        thing.name = 'chair'
+        subject.save(thing)
+        expect(subject.find(thing.id).name).to eq 'chair'
       end
     end
   end

data/spec/shared/repository_ext/timestampable.rb

@@ -1,68 +1,66 @@
 RSpec.shared_examples 'timestampable repository' do
-  describe Rmodel::Base::RepositoryExt::Timestampable do
-    context 'when the entity object has attributes created_at and updated_at' do
-      before do
-        stub_const('Thing', Struct.new(:id, :name, :created_at, :updated_at))
-      end
-
-      subject { repo_w_timestamps }
-
-      context 'when we insert(object)' do
-        context 'and the object.created_at is already set' do
-          let(:thing) { Thing.new(nil, 'chair', Time.now) }
+  context 'when the entity object has attributes created_at and updated_at' do
+    before do
+      stub_const('Thing', Struct.new(:id, :name, :created_at, :updated_at))
+    end
 
-          it 'doesnt change the value of created_at' do
-            set_created_at = thing.created_at
-            subject.insert(thing)
-            expect(thing.created_at).to eq set_created_at
-          end
-        end
+    subject { repo_w_timestamps }
 
-        context 'and the object.created_at is not set yet' do
-          let(:thing) { Thing.new(nil, 'chair') }
+    context 'when we insert(object)' do
+      context 'and the object.created_at is already set' do
+        let(:thing) { Thing.new(nil, 'chair', Time.now) }
 
-          it 'sets the value of created_at' do
-            subject.insert(thing)
-            expect(thing.created_at).not_to be_nil
-          end
+        it 'doesnt change the value of created_at' do
+          set_created_at = thing.created_at
+          subject.insert(thing)
+          expect(thing.created_at).to eq set_created_at
         end
       end
 
-      context 'when we update(object)' do
+      context 'and the object.created_at is not set yet' do
         let(:thing) { Thing.new(nil, 'chair') }
-        before { subject.insert(thing) }
 
         it 'sets the value of created_at' do
-          thing.name = 'table'
-          subject.update(thing)
-          expect(thing.updated_at).not_to be_nil
+          subject.insert(thing)
+          expect(thing.created_at).not_to be_nil
         end
       end
     end
 
-    context 'when the entity has no attributes :created_at and updated_at' do
-      before do
-        stub_const('Thing', Struct.new(:id, :name))
+    context 'when we update(object)' do
+      let(:thing) { Thing.new(nil, 'chair') }
+      before { subject.insert(thing) }
+
+      it 'sets the value of created_at' do
+        thing.name = 'table'
+        subject.update(thing)
+        expect(thing.updated_at).not_to be_nil
       end
+    end
+  end
 
-      let(:thing) { Thing.new(nil, 'chair') }
-      subject { repo_wo_timestamps }
+  context 'when the entity has no attributes :created_at and updated_at' do
+    before do
+      stub_const('Thing', Struct.new(:id, :name))
+    end
 
-      context 'when we insert(object)' do
-        it 'does nothing special' do
-          subject.insert(thing)
-          expect(thing.respond_to?(:created_at)).to be false
-        end
+    let(:thing) { Thing.new(nil, 'chair') }
+    subject { repo_wo_timestamps }
+
+    context 'when we insert(object)' do
+      it 'does nothing special' do
+        subject.insert(thing)
+        expect(thing.respond_to?(:created_at)).to be false
       end
+    end
 
-      context 'when we update(object)' do
-        before { subject.insert(thing) }
+    context 'when we update(object)' do
+      before { subject.insert(thing) }
 
-        it 'does nothing special' do
-          thing.name = 'table'
-          subject.update(thing)
-          expect(thing.respond_to?(:updated_at)).to be false
-        end
+      it 'does nothing special' do
+        thing.name = 'table'
+        subject.update(thing)
+        expect(thing.respond_to?(:updated_at)).to be false
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rmodel
 version: !ruby/object:Gem::Version
-  version: 0.2.2.pre.dev
+  version: 0.3.0.pre.dev
 platform: ruby
 authors:
 - Alexei
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-27 00:00:00.000000000 Z
+date: 2015-10-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongo
@@ -52,6 +52,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sequel
+  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
@@ -94,6 +108,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  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
@@ -109,6 +137,7 @@ files:
 - README.md
 - Rakefile
 - examples/advanced_creation_of_repository.rb
+- examples/sql_repository.rb
 - examples/timestamps.rb
 - examples/user.rb
 - lib/rmodel.rb
@@ -121,17 +150,26 @@ files:
 - lib/rmodel/mongo/repository_ext/queryable.rb
 - lib/rmodel/mongo/setup.rb
 - lib/rmodel/mongo/simple_factory.rb
+- lib/rmodel/sequel/repository.rb
+- lib/rmodel/sequel/repository_ext/query.rb
+- lib/rmodel/sequel/repository_ext/queryable.rb
+- lib/rmodel/sequel/setup.rb
+- lib/rmodel/sequel/simple_factory.rb
 - lib/rmodel/setup.rb
 - lib/rmodel/version.rb
 - rmodel.gemspec
-- spec/rmodel/mongo/repository_crud_spec.rb
 - spec/rmodel/mongo/repository_ext/queryable_spec.rb
-- spec/rmodel/mongo/repository_ext/sugarable_spec.rb
-- spec/rmodel/mongo/repository_ext/timestampable_spec.rb
 - spec/rmodel/mongo/repository_initialize_spec.rb
+- spec/rmodel/mongo/repository_spec.rb
 - spec/rmodel/mongo/simple_factory_spec.rb
+- spec/rmodel/sequel/repository_ext/queryable_spec.rb
+- spec/rmodel/sequel/repository_initialize_spec.rb
+- spec/rmodel/sequel/repository_spec.rb
+- spec/rmodel/sequel/simple_factory_spec.rb
 - spec/rmodel/setup_spec.rb
 - spec/shared/clean_moped.rb
+- spec/shared/clean_sequel.rb
+- spec/shared/repository_ext/crud.rb
 - spec/shared/repository_ext/sugarable.rb
 - spec/shared/repository_ext/timestampable.rb
 - spec/spec_helper.rb
@@ -160,14 +198,18 @@ 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_ext/queryable_spec.rb
-- spec/rmodel/mongo/repository_ext/sugarable_spec.rb
-- spec/rmodel/mongo/repository_ext/timestampable_spec.rb
 - spec/rmodel/mongo/repository_initialize_spec.rb
+- spec/rmodel/mongo/repository_spec.rb
 - spec/rmodel/mongo/simple_factory_spec.rb
+- spec/rmodel/sequel/repository_ext/queryable_spec.rb
+- spec/rmodel/sequel/repository_initialize_spec.rb
+- spec/rmodel/sequel/repository_spec.rb
+- spec/rmodel/sequel/simple_factory_spec.rb
 - spec/rmodel/setup_spec.rb
 - spec/shared/clean_moped.rb
+- spec/shared/clean_sequel.rb
+- spec/shared/repository_ext/crud.rb
 - spec/shared/repository_ext/sugarable.rb
 - spec/shared/repository_ext/timestampable.rb
 - spec/spec_helper.rb

data/spec/rmodel/mongo/repository_crud_spec.rb

@@ -1,90 +0,0 @@
-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))
-  end
-
-  let(:factory) { Rmodel::Mongo::SimpleFactory.new(User, :name, :email) }
-  subject(:repo) { UserRepository.new(mongo_session, :users, factory) }
-
-  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 '#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_ext/sugarable_spec.rb

@@ -1,14 +0,0 @@
-RSpec.describe Rmodel::Mongo::Repository do
-  include_examples 'sugarable repository' do
-    include_context 'clean Mongo database'
-
-    before do
-      stub_const('ThingRepository', Class.new(Rmodel::Mongo::Repository))
-    end
-
-    subject do
-      factory = Rmodel::Mongo::SimpleFactory.new(Thing, :name)
-      ThingRepository.new(mongo_session, :things, factory)
-    end
-  end
-end

data/spec/rmodel/mongo/repository_ext/timestampable_spec.rb

@@ -1,19 +0,0 @@
-RSpec.describe Rmodel::Mongo::Repository do
-  include_examples 'timestampable repository' do
-    include_context 'clean Mongo database'
-
-    before do
-      stub_const('ThingRepository', Class.new(Rmodel::Mongo::Repository))
-    end
-
-    let(:repo_w_timestamps) do
-      factory = Rmodel::Mongo::SimpleFactory.new(Thing, :name, :created_at, :updated_at)
-      ThingRepository.new(mongo_session, :things, factory)
-    end
-
-    let(:repo_wo_timestamps) do
-      factory = Rmodel::Mongo::SimpleFactory.new(Thing, :name)
-      ThingRepository.new(mongo_session, :things, factory)
-    end
-  end
-end