rmodel 0.4.0.dev → 1.0.0

data/lib/rmodel/repository.rb

@@ -0,0 +1,36 @@
+require 'rmodel/repository_ext/sugarable'
+require 'rmodel/repository_ext/timestampable'
+require 'rmodel/repository_ext/scopable'
+
+module Rmodel
+  class Repository
+    include RepositoryExt::Sugarable
+    include RepositoryExt::Scopable
+    prepend RepositoryExt::Timestampable
+
+    def initialize(source, mapper)
+      @source = source or raise ArgumentError, 'Source is not set up'
+      @mapper = mapper or raise ArgumentError, 'Mapper is not set up'
+    end
+
+    def find(id)
+      record = @source.find(id)
+      @mapper.deserialize(record)
+    end
+
+    def insert_one(object)
+      record = @mapper.serialize(object, true)
+      id = @source.insert(record)
+      object.id ||= id
+    end
+
+    def update(object)
+      record = @mapper.serialize(object, false)
+      @source.update(object.id, record)
+    end
+
+    def destroy(object)
+      @source.delete(object.id)
+    end
+  end
+end

data/lib/rmodel/repository_ext/scopable.rb

@@ -0,0 +1,44 @@
+module Rmodel
+  module RepositoryExt
+    module Scopable
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def fetch
+        self.class.scope_class.new(self, @source.build_query)
+      end
+
+      def find_all(scope = nil)
+        raw_query = (scope || fetch).raw_query
+
+        @source.exec_query(raw_query).map do |hash|
+          @mapper.deserialize(hash)
+        end
+      end
+
+      def delete_all(scope = nil)
+        raw_query = (scope || fetch).raw_query
+        @source.delete_by_query(raw_query)
+      end
+
+      def destroy_all(scope = nil)
+        find_all(scope).each { |object| destroy(object) }
+      end
+
+      def all
+        fetch.to_a
+      end
+
+      module ClassMethods
+        def scope_class
+          @scope_class ||= Class.new(Rmodel::Scope)
+        end
+
+        def scope(name, &block)
+          scope_class.define_scope(name, &block)
+        end
+      end
+    end
+  end
+end

data/lib/rmodel/repository_ext/sugarable.rb

@@ -0,0 +1,35 @@
+module Rmodel
+  module RepositoryExt
+    module Sugarable
+      def find!(id)
+        find(id) or raise(Rmodel::NotFound.new(self, id: id))
+      end
+
+      def insert(*args)
+        if args.length == 1
+          if args.first.is_a?(Array)
+            insert_array(args.first)
+          else
+            insert_one(args.first)
+          end
+        else
+          insert_array(args)
+        end
+      end
+
+      def save(object)
+        if object.id.nil?
+          insert_one(object)
+        else
+          update(object)
+        end
+      end
+
+      private
+
+      def insert_array(array)
+        array.each { |object| insert_one(object) }
+      end
+    end
+  end
+end

data/lib/rmodel/repository_ext/timestampable.rb

@@ -0,0 +1,29 @@
+module Rmodel
+  module RepositoryExt
+    module Timestampable
+      def insert_one(object)
+        object.created_at = now if able_to_set_created_at?(object)
+        super
+      end
+
+      def update(object)
+        object.updated_at = now if able_to_set_updated_at?(object)
+        super
+      end
+
+      private
+
+      def able_to_set_created_at?(object)
+        object.respond_to?(:created_at=) && object.created_at.nil?
+      end
+
+      def able_to_set_updated_at?(object)
+        object.respond_to?(:updated_at=)
+      end
+
+      def now
+        Time.try(:current) || Time.now
+      end
+    end
+  end
+end

data/lib/rmodel/scope.rb

@@ -0,0 +1,31 @@
+module Rmodel
+  class Scope
+    include Enumerable
+
+    attr_reader :raw_query
+
+    def initialize(repo, raw_query)
+      @repo = repo
+      @raw_query = raw_query
+    end
+
+    def each(&block)
+      @repo.find_all(self).each(&block)
+    end
+
+    def delete_all
+      @repo.delete_all(self)
+    end
+
+    def destroy_all
+      @repo.destroy_all(self)
+    end
+
+    def self.define_scope(name, &block)
+      define_method name do |*args|
+        new_raw_query = @raw_query.instance_exec(*args, &block)
+        self.class.new(@repo, new_raw_query)
+      end
+    end
+  end
+end

data/lib/rmodel/sequel/mapper.rb

@@ -0,0 +1,6 @@
+module Rmodel
+  module Sequel
+    class Mapper < Rmodel::BaseMapper
+    end
+  end
+end

data/lib/rmodel/sequel/source.rb

@@ -0,0 +1,43 @@
+require 'sequel'
+
+module Rmodel
+  module Sequel
+    class Source
+      def initialize(connection, table)
+        @connection = connection
+        raise ArgumentError, 'Connection is not setup' unless @connection
+
+        @table = table
+        raise ArgumentError, 'Table can not be guessed' unless @table
+      end
+
+      def find(id)
+        @connection[@table].where(id: id).first
+      end
+
+      def insert(tuple)
+        @connection[@table].insert(tuple)
+      end
+
+      def update(id, tuple)
+        @connection[@table].where(id: id).update(tuple)
+      end
+
+      def delete(id)
+        @connection[@table].where(id: id).delete
+      end
+
+      def build_query
+        @connection[@table]
+      end
+
+      def exec_query(query)
+        query
+      end
+
+      def delete_by_query(query)
+        exec_query(query).delete
+      end
+    end
+  end
+end

data/lib/rmodel/uni_hash.rb

@@ -0,0 +1,16 @@
+module Rmodel
+  class UniHash < SimpleDelegator
+    def initialize(hash, key_op)
+      super(hash)
+      @key_op = key_op
+    end
+
+    def [](key)
+      super(key.public_send(@key_op))
+    end
+
+    def []=(key, value)
+      super(key.public_send(@key_op), value)
+    end
+  end
+end

data/lib/rmodel/version.rb

@@ -1,3 +1,3 @@
 module Rmodel
-  VERSION = "0.4.0.dev"
+  VERSION = '1.0.0'.freeze
 end

data/rmodel.gemspec

@@ -8,8 +8,10 @@ Gem::Specification.new do |spec|
   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.summary       = 'Rmodel is an ORM library, which tends to follow the
+    SOLID principles.'
+  spec.description   = 'Rmodel is an ORM library, which tends to follow the
+    SOLID principles.'
   spec.homepage      = 'https://github.com/alexei-lexx/rmodel'
   spec.license       = 'MIT'
 
@@ -19,7 +21,6 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_dependency 'mongo', '~> 2.1'
-  spec.add_dependency 'activesupport'
   spec.add_dependency 'origin'
   spec.add_dependency 'sequel'
 
@@ -27,6 +28,11 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'rake'
   spec.add_development_dependency 'rspec'
   spec.add_development_dependency 'sqlite3'
+  spec.add_development_dependency 'rubocop'
+  spec.add_development_dependency 'activesupport'
+  spec.add_development_dependency 'sinatra'
+  spec.add_development_dependency 'activemodel'
+  spec.add_development_dependency 'lazy_injector'
 
   spec.required_ruby_version = '>= 2.0.0'
 end

data/spec/rmodel/array_mapper_spec.rb

@@ -0,0 +1,43 @@
+RSpec.describe Rmodel::ArrayMapper do
+  before { stub_const 'Thing', Struct.new(:id, :name) }
+
+  let(:mapper) { Rmodel::Mongo::Mapper.new(Thing).define_attributes(:name) }
+
+  subject { described_class.new(mapper) }
+
+  describe '#deserialize(array)' do
+    it 'returns an array of instances of the appropriate class' do
+      objects = subject.deserialize([{}, {}])
+
+      expect(objects.length).to eq 2
+      objects.each do |object|
+        expect(object).to be_an_instance_of Thing
+      end
+    end
+
+    context 'when nil is given' do
+      it 'returns nil' do
+        expect(subject.deserialize(nil)).to be_nil
+      end
+    end
+  end
+
+  describe '#serialize(objects, id_included)' do
+    it 'returns an instance of Array' do
+      things = [Thing.new(1, 'chair'), Thing.new(2, 'table')]
+      array = subject.serialize(things, true)
+
+      expect(array.length).to eq 2
+      array.each do |entry|
+        expect(entry['_id']).not_to be_nil
+        expect(entry['name']).not_to be_nil
+      end
+    end
+
+    context 'when nil is given' do
+      it 'returns nil' do
+        expect(subject.serialize(nil, true)).to be_nil
+      end
+    end
+  end
+end

data/spec/rmodel/mongo/mapper_spec.rb

@@ -0,0 +1,154 @@
+RSpec.describe Rmodel::Mongo::Mapper do
+  before do
+    stub_const 'User', Struct.new(:id, :name, :age, :address, :phones)
+    stub_const 'Address', Struct.new(:id, :city, :street)
+    stub_const 'Phone', Struct.new(:id, :number)
+  end
+
+  let(:address_mapper) do
+    described_class.new(Address).define_attributes(:city, :street)
+  end
+
+  let(:phone_mapper) do
+    described_class.new(Phone).define_attributes(:number)
+  end
+
+  subject do
+    phones_mapper = Rmodel::ArrayMapper.new(phone_mapper)
+    described_class.new(User)
+                   .define_attributes(:name, :age)
+                   .define_attribute(:address, address_mapper)
+                   .define_attribute(:phones, phones_mapper)
+  end
+
+  describe '#deserialize(hash)' do
+    it 'returns an instance of the appropriate class' do
+      expect(subject.deserialize({})).to be_an_instance_of User
+    end
+
+    it 'sets the attributes correctly' do
+      object = subject.deserialize('name' => 'John', 'age' => 20)
+
+      expect(object.name).to eq 'John'
+      expect(object.age).to eq 20
+    end
+
+    it 'leaves not specified attributes out' do
+      object = subject.deserialize('name' => 'John')
+      expect(object.age).to be_nil
+    end
+
+    context 'when _id is given' do
+      it 'sets the #id correctly' do
+        object = subject.deserialize('_id' => 1)
+        expect(object.id).to eq 1
+      end
+    end
+
+    context 'when an embedded hash is given' do
+      let(:hash) do
+        {
+          'address' => {
+            '_id' => 10,
+            'city' => 'NY',
+            'street' => '1st Avenue'
+          }
+        }
+      end
+      let(:object) { subject.deserialize(hash) }
+
+      it 'creates the embedded object of the appropriate type' do
+        expect(object.address).to be_an_instance_of Address
+      end
+
+      it 'sets the attributes of the embedded object correctly' do
+        expect(object.address.id).to eq 10
+        expect(object.address.city).to eq 'NY'
+        expect(object.address.street).to eq '1st Avenue'
+      end
+    end
+
+    context 'when an embedded array is given' do
+      let(:hash) do
+        {
+          'phones' => [
+            { '_id' => 100, 'number' => '+1111' },
+            { '_id' => 101, 'number' => '+2222' }
+          ]
+        }
+      end
+      let(:object) { subject.deserialize(hash) }
+
+      it 'creates the embedded array of objects of the appropriate type' do
+        expect(object.phones).to be_an_instance_of Array
+        expect(object.phones.length).to eq 2
+      end
+
+      it 'sets the attributes of the embedded array correctly' do
+        expect(object.phones[0].id).to eq 100
+        expect(object.phones[0].number).to eq '+1111'
+
+        expect(object.phones[1].id).to eq 101
+        expect(object.phones[1].number).to eq '+2222'
+      end
+    end
+  end
+
+  describe '#serialize(object, id_included)' do
+    it 'returns an instance of Hash' do
+      hash = subject.serialize(User.new(1, 'John', 20), true)
+      expect(hash).to be_an_instance_of Hash
+    end
+
+    it 'sets the keys correctly' do
+      hash = subject.serialize(User.new(1, 'John', 20), true)
+
+      expect(hash['name']).to eq 'John'
+      expect(hash['age']).to eq 20
+    end
+
+    context 'when id_included = true' do
+      it 'sets the _id' do
+        hash = subject.serialize(User.new(1), true)
+        expect(hash['_id']).to eq 1
+      end
+    end
+
+    context 'when id_included = false' do
+      it 'doesnt set the _id' do
+        hash = subject.serialize(User.new(1), false)
+        expect(hash.key?('_id')).to be false
+      end
+    end
+
+    context 'when an embedded object is given' do
+      let(:object) do
+        user = User.new(1, 'John', 20)
+        user.address = Address.new(10, 'NY', '1st Avenue')
+        user
+      end
+      let(:hash) { subject.serialize(object, true) }
+
+      it 'creates the embedded hash correctly' do
+        expect(hash['address']['_id']).to eq 10
+        expect(hash['address']['city']).to eq 'NY'
+        expect(hash['address']['street']).to eq '1st Avenue'
+      end
+    end
+
+    context 'when an embedded array of objects is given' do
+      let(:object) do
+        user = User.new
+        user.phones = [Phone.new(100, '+1111'), Phone.new(101, '+2222')]
+        user
+      end
+      let(:hash) { subject.serialize(object, true) }
+
+      it 'creates the embedded array correctly' do
+        expect(hash['phones'].length).to eq 2
+      end
+    end
+  end
+
+  it_behaves_like 'base mapper'
+end