rmodel 0.3.1.dev → 0.4.0.dev

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0f799f5512a154a18435f2fd1b32f5143c3a520a
-  data.tar.gz: 9452ccc5d051436556d50db6dbc5add3256a5189
+  metadata.gz: bfd28def37943474200080f54ed361a5a7ff742c
+  data.tar.gz: 09936b026f1c1d5b232cafe8ccce68665726a0eb
 SHA512:
-  metadata.gz: f1b7e7218d9ac0e476d71bc9c0533b784d3a0de490efcbbe64f5b843aedfd378ca1c729c72a5a1ca401bfee59fee2268b0e243332423ae87b82aad8743379f43
-  data.tar.gz: 09a28541977e304e63b83a1d57ceb42e391f1b060404e548e4121e83a4c1a408960b5a14dc6f844d54c27cdd12d0d7575e7ce24b2009c6345a9fc474c79abd0f
+  metadata.gz: d7857a21445b42cab34bb02205949cbb3204cd245fd59508204cfca4cfa6c74753f698d1d5ce56596559dc03dbbe5abd58ab6092ca486332b426c9e887d6fa94
+  data.tar.gz: fd441d8e206b3d21eb0cc636c6c178e319f7fe05114b5924e44d0440ff1f6b572735642e4080a255729580a21a6353b960ef7f2520664f62def8d8632ba0273f

data/README.md

@@ -10,12 +10,13 @@
   * [Sugar methods](#sugar-methods)
   * [Advanced creation of repository](#advanced-creation-of-repository)
   * [SQL repository](#sql-repository)
+  * [Embedded documents in MongoDB](#embedded-documents-in-mongodb)
 
 Rmodel is an ORM library, which tends to follow the SOLID principles.
 
 **Currently works with MongoDB and SQL databases supported by Sequel.**
 
-The main thoughts behind it are:
+The main thoughts of it are:
 
 * let you models be simple and independent of the persistent layer,
 * be able to switch the persistent layer at any moment,
@@ -32,7 +33,7 @@ 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`
+3. Query-based operations: `userRepository.query.recent.remove`
 
 ## Installation
 
@@ -281,6 +282,114 @@ p repo.query.worth_more_than(400).count # 1
 p repo.query.worth_more_than(400).to_sql
 ```
 
+### Embedded documents in MongoDB
+
+Let's assume that we have the `flats` collection and every documents reveals
+the following structure.
+
+```js
+> db.flats.findOne()
+{
+	"_id" : ObjectId("5632910ee5fcc32d40000000"),
+	"address" : "Googleplex, Mountain View, California, U.S",
+	"rooms" : [
+		{
+			"name" : "dining room",
+			"square" : 150,
+			"_id" : ObjectId("5632910ee5fcc32d40000001")
+		},
+		{
+			"name" : "sleeping room #1",
+			"square" : 50,
+			"_id" : ObjectId("5632910ee5fcc32d40000002"),
+			"bed" : {
+				"type" : "single",
+				"_id" : ObjectId("5632910ee5fcc32d40000003")
+			}
+		},
+		{
+			"name" : "sleeping room #2",
+			"square" : 20,
+			"_id" : ObjectId("5632910ee5fcc32d40000004"),
+			"bed" : {
+				"type" : "king-size",
+				"_id" : ObjectId("5632910ee5fcc32d40000005")
+			}
+		}
+	],
+	"owner" : {
+		"first_name" : "John",
+		"last_name" : "Doe",
+		"_id" : ObjectId("5632910ee5fcc32d40000006")
+	}
+}
+```
+
+We need a rather complicated factory to build such object. Here is the example how we can map nested embedded documents with SimpleFactory.
+
+```ruby
+Owner = Struct.new(:id, :first_name, :last_name)
+Room = Struct.new(:id, :name, :square, :bed)
+Flat = Struct.new(:id, :address, :rooms, :owner)
+Bed = Struct.new(:id, :type)
+
+class FlatRepository < Rmodel::Mongo::Repository
+  simple_factory Flat, :address do
+    embeds_many :rooms, simple_factory(Room, :name, :square) do
+      embeds_one :bed, simple_factory(Bed, :type)
+    end
+    embeds_one :owner, simple_factory(Owner, :first_name, :last_name)
+  end
+end
+```
+
+1. The row `simple_factory Flat, :address` create a factory for Flat.
+  * It takes a block, where the detailed declaration goes.
+  * `embeds_many` and `embeds_one` are methods of the created factory.
+2. The row `embeds_many :rooms, simple_factory(Room, :name, :square)` describes  the embedded array of rooms within the flat.
+  * The first argument `:room` is the name of the flat attribute (`flat.rooms`).
+  * The second argument is another simple factory for the Room class.
+  * The row `embeds_many :rooms` takes the block, that described nested embedded documents for the Room factory.
+3. etc.
+
+The full example.
+
+```ruby
+require 'rmodel'
+
+Rmodel.setup do
+  client :default, { hosts: [ 'localhost'], database: 'test' }
+end
+
+Owner = Struct.new(:id, :first_name, :last_name)
+Room = Struct.new(:id, :name, :square, :bed)
+Flat = Struct.new(:id, :address, :rooms, :owner)
+Bed = Struct.new(:id, :type)
+
+class FlatRepository < Rmodel::Mongo::Repository
+  simple_factory Flat, :address do
+    embeds_many :rooms, simple_factory(Room, :name, :square) do
+      embeds_one :bed, simple_factory(Bed, :type)
+    end
+    embeds_one :owner, simple_factory(Owner, :first_name, :last_name)
+  end
+end
+repo = FlatRepository.new
+repo.query.remove
+
+flat = Flat.new
+flat.address = 'Googleplex, Mountain View, California, U.S'
+flat.rooms = [
+  Room.new(nil, 'dining room', 150),
+  Room.new(nil, 'sleeping room #1', 50, Bed.new(nil, 'single')),
+  Room.new(nil, 'sleeping room #2', 20, Bed.new(nil, 'king-size'))
+]
+flat.owner = Owner.new(nil, 'John', 'Doe')
+
+repo.insert(flat)
+p repo.find(flat.id)
+```
+
 ## Contributing
 
 1. Fork it ( https://github.com/alexei-lexx/rmodel/fork )

data/examples/mongo_embedded.rb

@@ -0,0 +1,33 @@
+require 'rmodel'
+
+Rmodel.setup do
+  client :default, { hosts: [ 'localhost'], database: 'test' }
+end
+
+Owner = Struct.new(:id, :first_name, :last_name)
+Room = Struct.new(:id, :name, :square, :bed)
+Flat = Struct.new(:id, :address, :rooms, :owner)
+Bed = Struct.new(:id, :type)
+
+class FlatRepository < Rmodel::Mongo::Repository
+  simple_factory Flat, :address do
+    embeds_many :rooms, simple_factory(Room, :name, :square) do
+      embeds_one :bed, simple_factory(Bed, :type)
+    end
+    embeds_one :owner, simple_factory(Owner, :first_name, :last_name)
+  end
+end
+repo = FlatRepository.new
+repo.query.remove
+
+flat = Flat.new
+flat.address = 'Googleplex, Mountain View, California, U.S'
+flat.rooms = [
+  Room.new(nil, 'dining room', 150),
+  Room.new(nil, 'sleeping room #1', 50, Bed.new(nil, 'single')),
+  Room.new(nil, 'sleeping room #2', 20, Bed.new(nil, 'king-size'))
+]
+flat.owner = Owner.new(nil, 'John', 'Doe')
+
+repo.insert(flat)
+p repo.find(flat.id)

data/lib/rmodel/mongo/repository.rb

@@ -54,8 +54,8 @@ module Rmodel::Mongo
         end
       end
 
-      def simple_factory(klass, *attributes)
-        @setting_factory = SimpleFactory.new(klass, *attributes)
+      def simple_factory(klass, *attributes, &block)
+        @setting_factory = SimpleFactory.new(klass, *attributes, &block)
       end
     end
   end

data/lib/rmodel/mongo/simple_factory.rb

@@ -1,8 +1,11 @@
 module Rmodel::Mongo
   class SimpleFactory
-    def initialize(klass, *attributes)
+    def initialize(klass, *attributes, &block)
       @klass = klass
       @attributes = attributes
+      @embeds_many = {}
+      @embeds_one = {}
+      instance_eval(&block) if block
     end
 
     def fromHash(hash)
@@ -11,6 +14,20 @@ module Rmodel::Mongo
       @attributes.each do |attribute|
         object.public_send "#{attribute}=", hash[attribute.to_s]
       end
+      @embeds_many.each do |attribute, factory|
+        if hash[attribute.to_s]
+          object.public_send "#{attribute}=", []
+          hash[attribute.to_s].each do |sub_hash|
+            object.public_send(attribute) << factory.fromHash(sub_hash)
+          end
+        end
+      end
+      @embeds_one.each do |attribute, factory|
+        sub_hash = hash[attribute.to_s]
+        if sub_hash
+          object.public_send "#{attribute}=", factory.fromHash(sub_hash)
+        end
+      end
       object
     end
 
@@ -22,7 +39,40 @@ module Rmodel::Mongo
       if id_included
         hash['_id'] = object.id
       end
+      @embeds_many.each do |attribute, factory|
+        hash[attribute.to_s] = []
+        sub_objects = object.public_send(attribute)
+        if sub_objects
+          sub_objects.each do |sub_object|
+            sub_object.id ||= BSON::ObjectId.new
+            hash[attribute.to_s] << factory.toHash(sub_object, true)
+          end
+        end
+      end
+      @embeds_one.each do |attribute, factory|
+        sub_object = object.public_send(attribute)
+        if sub_object
+          sub_object.id ||= BSON::ObjectId.new
+          hash[attribute.to_s] = factory.toHash(sub_object, true)
+        end
+      end
       hash
     end
+
+    private
+
+    def embeds_many(attribute, factory, &block)
+      factory.instance_eval(&block) if block
+      @embeds_many[attribute.to_sym] = factory
+    end
+
+    def embeds_one(attribute, factory, &block)
+      factory.instance_eval(&block) if block
+      @embeds_one[attribute.to_sym] = factory
+    end
+
+    def simple_factory(klass, *attributes, &block)
+      self.class.new(klass, *attributes, &block)
+    end
   end
 end

data/lib/rmodel/version.rb

@@ -1,3 +1,3 @@
 module Rmodel
-  VERSION = "0.3.1.dev"
+  VERSION = "0.4.0.dev"
 end

data/spec/rmodel/mongo/repository_initialize_spec.rb

@@ -1,5 +1,6 @@
 RSpec.describe Rmodel::Mongo::Repository do
   before do
+    Mongo::Logger.logger.level = Logger::ERROR
     stub_const('User', Struct.new(:id, :name, :email))
   end
 
@@ -108,7 +109,7 @@ RSpec.describe Rmodel::Mongo::Repository do
     end
   end
 
-  describe '.simple_factory(klass, attribute1, attribute2, ...)' do
+  describe '.simple_factory(klass, attribute1, attribute2, ..., &block)' do
     subject { UserRepository.new }
 
     before do
@@ -142,6 +143,18 @@ RSpec.describe Rmodel::Mongo::Repository do
         }.to raise_error ArgumentError
       end
     end
+
+    context 'when a block is given' do
+      it 'evaluates the block within the context of the factory' do
+        tmp = nil
+        stub_const('UserRepository', Class.new(Rmodel::Mongo::Repository) {
+          simple_factory User, :name, :email do
+            tmp = self
+          end
+        })
+        expect(tmp).to be_an_instance_of Rmodel::Mongo::SimpleFactory
+      end
+    end
   end
 
   describe '#initialize(client, collection, factory)' do

data/spec/rmodel/mongo/simple_factory_spec.rb

@@ -1,41 +1,123 @@
 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)) }
+  context 'when the Thing(id, name, price, parts, owner) class is defined' do
+    before do
+      stub_const('Thing', Struct.new(:id, :name, :price, :parts, :owner))
+      stub_const('Part', Struct.new(:id, :name, :producer))
+      stub_const('Producer', Struct.new(:id, :country))
+      stub_const('Owner', Struct.new(:id, :full_name, :phones))
+      stub_const('Phone', Struct.new(:id, :number))
+    end
+
+    subject do
+      described_class.new(Thing, :name, :price) do
+        embeds_many :parts, simple_factory(Part, :name) do
+          embeds_one :producer, simple_factory(Producer, :country)
+        end
+        embeds_one :owner, simple_factory(Owner, :full_name) do
+          embeds_many :phones, simple_factory(Phone, :number)
+        end
+      end
+    end
 
-    subject(:factory) { described_class.new(User, :name, :email) }
+    describe '#fromHash(hash)' do
+      let(:result) { subject.fromHash(hash) }
 
-    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) }
+      context 'when the hash with _id, name and price is given' do
+        let(:hash) { { '_id' => 1, 'name' => 'chair', 'price' => 100 } }
 
-        it 'returns an instance of User' do
-          expect(result).to be_an_instance_of User
+        it 'returns an instance of Thing' do
+          expect(result).to be_an_instance_of Thing
         end
 
         it 'sets the attributes correctly' do
-          expect(result.name).to eq 'John'
-          expect(result.email).to eq 'john@example.com'
+          expect(result.name).to eq 'chair'
+          expect(result.price).to eq 100
         end
 
-        it 'sets the User#id correctly' do
+        it 'sets the Thing#id correctly' do
           expect(result.id).to eq 1
         end
+
+        it 'leaves <many embedded> nil' do
+          expect(result.parts).to be_nil
+        end
+
+        it 'leaves <one embedded> nil' do
+          expect(result.owner).to be_nil
+        end
+      end
+
+      context 'when the hash contains many parts' do
+        let(:hash) do
+          {
+            'parts' => [
+              { '_id' => 1, 'name' => 'back', 'producer' => { '_id' => 10, 'country' => 'UK' } },
+              { '_id' => 2, 'name' => 'leg' }
+            ]
+          }
+        end
+
+        it 'maps subdocuments to <many embedded>' do
+          expect(result.parts.length).to eq 2
+
+          expect(result.parts[0]).to be_an_instance_of Part
+          expect(result.parts[0].id).to eq 1
+          expect(result.parts[0].name).to eq 'back'
+
+          expect(result.parts[0].producer).to be_an_instance_of Producer
+          expect(result.parts[0].producer.id).to eq 10
+          expect(result.parts[0].producer.country).to eq 'UK'
+
+          expect(result.parts[1]).to be_an_instance_of Part
+          expect(result.parts[1].id).to eq 2
+          expect(result.parts[1].name).to eq 'leg'
+          expect(result.parts[1].producer).to be_nil
+        end
+      end
+
+      context 'when the hash contains one owner' do
+        let(:hash) do
+          {
+            'owner' => {
+              '_id' => 3,
+              'full_name' => 'John Doe',
+              'phones' => [
+                { '_id' => 20, 'number' => '+1111111111' },
+                { '_id' => 21, 'number' => '+2222222222' }
+              ]
+            }
+           }
+        end
+
+        it 'maps subdocument to <one embedded>' do
+          expect(result.owner).to be_an_instance_of Owner
+          expect(result.owner.id).to eq 3
+          expect(result.owner.full_name).to eq 'John Doe'
+
+          expect(result.owner.phones.length).to eq 2
+
+          expect(result.owner.phones[0].id).to eq 20
+          expect(result.owner.phones[0].number).to eq '+1111111111'
+
+          expect(result.owner.phones[1].id).to eq 21
+          expect(result.owner.phones[1].number).to eq '+2222222222'
+        end
       end
     end
 
-    describe '#toHash' do
-      let(:user) { User.new(1, 'John', 'john@example.com') }
+    describe '#toHash(object, id_included)' do
+      let(:thing) { Thing.new(1, 'chair', 100) }
+
       context 'when id_included is false' do
-        let(:result) { factory.toHash(user, false) }
+        let(:result) { subject.toHash(thing, 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'
+          expect(result['name']).to eq 'chair'
+          expect(result['price']).to eq 100
         end
 
         it 'has no the "_id" key' do
@@ -44,12 +126,70 @@ RSpec.describe Rmodel::Mongo::SimpleFactory do
       end
 
       context 'when id_included is true' do
-        let(:result) { factory.toHash(user, true) }
+        let(:result) { subject.toHash(thing, true) }
 
         it 'sets the "_id" key' do
           expect(result['_id']).to eq 1
         end
       end
+
+      context 'when the object has <many embedded>' do
+        let(:thing) do
+          Thing.new(1, 'chair', 100, [
+            Part.new(1, 'back', Producer.new(10, 'UK')),
+            Part.new(2, 'leg')
+          ])
+        end
+        let(:result) { subject.toHash(thing, true) }
+
+        it 'maps <many embedded> to subdocuments' do
+          expect(result['parts'].length).to eq 2
+
+          expect(result['parts'][0]['_id']).to eq 1
+          expect(result['parts'][0]['name']).to eq 'back'
+
+          expect(result['parts'][0]['producer']['_id']).to eq 10
+          expect(result['parts'][0]['producer']['country']).to eq 'UK'
+
+          expect(result['parts'][1]['_id']).to eq 2
+          expect(result['parts'][1]['name']).to eq 'leg'
+        end
+      end
+
+      context 'when the object has <one embedded>' do
+        let(:thing) do
+          Thing.new(1, 'chair', 100, nil, Owner.new(3, 'John Doe', [
+            Phone.new(20, '+1111111111'),
+            Phone.new(21, '+2222222222')
+          ]))
+        end
+        let(:result) { subject.toHash(thing, true) }
+
+        it 'maps <one embedded> to the subdocument' do
+          expect(result['owner']['_id']).to eq 3
+          expect(result['owner']['full_name']).to eq 'John Doe'
+
+          expect(result['owner']['phones'].length).to eq 2
+
+          expect(result['owner']['phones'][0]['_id']).to eq 20
+          expect(result['owner']['phones'][0]['number']).to eq '+1111111111'
+
+          expect(result['owner']['phones'][1]['_id']).to eq 21
+          expect(result['owner']['phones'][1]['number']).to eq '+2222222222'
+        end
+      end
+    end
+
+    describe '#initialize(..., &block)' do
+      context 'when a block is given' do
+        it 'passes self to the block' do
+          tmp = nil
+          factory = described_class.new(Thing, :name) do
+            tmp = self
+          end
+          expect(tmp).to be factory
+        end
+      end
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rmodel
 version: !ruby/object:Gem::Version
-  version: 0.3.1.dev
+  version: 0.4.0.dev
 platform: ruby
 authors:
 - Alexei
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-28 00:00:00.000000000 Z
+date: 2015-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongo
@@ -137,6 +137,7 @@ files:
 - README.md
 - Rakefile
 - examples/advanced_creation_of_repository.rb
+- examples/mongo_embedded.rb
 - examples/sql_repository.rb
 - examples/timestamps.rb
 - examples/user.rb