mongoload 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 78571a15bc95933c04087943f3b5f13ff672c199
-  data.tar.gz: acf8006f8200bc0c63bf3b173bee0ec573d9aafa
+  metadata.gz: 96fce1e2c2f42caf74c0bfb5674dcf18953aea98
+  data.tar.gz: 01454a26063e7ddecbf4cb7c3948bd634d5abf05
 SHA512:
-  metadata.gz: 28e7a8b10d772f055fd60c407d5c019b2bd2d2972b4dd824672e14eddd37d86ab59a12478e390b3f5db0a0230125fd864ddcce8db857130a5ff7f1ed6a6504a9
-  data.tar.gz: 7d0c29e43d846ea5c12e350bb325d2595b4d108314aedad9c7f6340eaaa53fda186ad4b8c04b58df10d008d5433fd2585ca5d4763adc99be40c17362666a73e8
+  metadata.gz: b8c5e970c9068f5b18c0bdd0bf6c361b633ca33353b5158961d771e59d9e4e049fa8cd4ab520aa2e21f7cd3d9a85cedf20930ef6de90a7187ca3ce4162d0a142
+  data.tar.gz: de7f5785b893aed061a9ed35221b5b624472edd47ed29253207c07fd5e8226bf54f370b3833f304ba000b6e48ba12325a575d6438e0c366f1ffa94751a1f3584

data/.travis.yml

@@ -3,8 +3,8 @@ sudo: false
 services: mongodb
 rvm:
   - "2.1.10"
-  - "2.2.4"
-  - "2.3.0"
+  - "2.2.5"
+  - "2.3.1"
 gemfile:
   - gemfiles/mongoid_50.gemfile
   - gemfiles/mongoid_51.gemfile

data/README.md

@@ -1,5 +1,5 @@
 # Mongoload
-
+[![Gem Version](https://badge.fury.io/rb/mongoload.svg)](https://badge.fury.io/rb/mongoload)
 [![Build Status](https://travis-ci.org/karloku/mongoload.svg?branch=master)](https://travis-ci.org/karloku/mongoload)
 
 Mongoload is a gem to perform eager loading automatically for Mongoid, inspired by [Goldiloader](https://github.com/salsify/goldiloader).
@@ -18,13 +18,53 @@ Or install it yourself as:
 
     $ gem install mongoload
 
-## TODO
+## Options
+
+### :auto_include
+
+Mark if Mongoload should perform eager loading on the relation.
+Pass ```:auto_include``` option to the definition, the value should be ```true```(by default) or ```false```.
+
+```ruby
+class User
+  include Mongoid::Document
+  has_one :device, auto_include: false # Do not perform automatic eager loading on :device relation
+  has_many :posts
+
+  field :username
+end
+
+# Following call will not trigger automatic eager loading on device
+User.all.each(&:device)
+```
+
+### :fully_load
+
+Mark if Mongoload should perform eager loading on the relation, when accessed by following methods:
+
+  + #first
+  + #last
+  + #size
+  + #empty?
+
+Pass ```:fully_load``` option to the definition, the value should be ```true``` or ```false```(by default).
+
+```ruby
+class Tag
+  include Mongoid::Document
+  has_and_belongs_to_many :posts, fully_load: true
+
+  field :name
+end
+
+# Following calls will trigger automatic eager loading on posts
+Tag.all.each { |tag| tag.posts.first }
+Tag.all.each { |tag| tag.posts.last }
+Tag.all.each { |tag| tag.posts.size }
+Tag.all.each { |tag| tag.posts.empty? }
+```
 
-* option to perform eager loading when calling following methods on an many/many_to_many relation:
-  + size
-  + first
-  + last
-+ option to disable eager loading on specific relation
+PS: As for ```#second```, ```#third```, ```#fourth```, ```#fifth``` and ```#forty_two``` calls, mongoid will delegate them to the entries of a relation enumerable set, which makes them just same as a ```#to_a``` call.
 
 ## Copyright
 

data/lib/mongoload.rb

@@ -3,7 +3,9 @@ require 'mongoid'
 require 'mongoload/version'
 require 'mongoload/auto_include_context'
 require 'mongoload/relation_loader'
-require 'mongoload/patches/mongoid_contextual_mongo_patch'
-require 'mongoload/patches/mongoid_document_patch'
-require 'mongoload/patches/mongoid_relations_accessors_patch'
-require 'mongoload/patches/mongoid_relations_targets_enumerable_patch'
+require 'mongoload/patches/contextual_mongo'
+require 'mongoload/patches/document'
+require 'mongoload/patches/relations_accessors'
+require 'mongoload/patches/relations_targets_enumerable'
+require 'mongoload/patches/relations_options'
+require 'mongoload/patches/relations_metadata'

data/lib/mongoload/patches/{mongoid_contextual_mongo_patch.rb → contextual_mongo.rb}

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module Mongoload
-  module MongoContextWithAutoInclude
+  module ContextWithAutoInclude
     def documents_for_iteration
       results = super
       if results.is_a?(Mongo::Collection::View)
@@ -13,4 +13,4 @@ module Mongoload
   end
 end
 
-Mongoid::Contextual::Mongo.prepend Mongoload::MongoContextWithAutoInclude
+Mongoid::Contextual::Mongo.prepend Mongoload::ContextWithAutoInclude

data/lib/mongoload/patches/relations_accessors.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module Mongoload
+  module RelationsAccessorsWithAutoInclude
+    private_class_method
+
+    def self.assign_missing_proxy_method(relation)
+      if relation.class == Mongoid::Relations::Targets::Enumerable
+        relation.target.define_singleton_method :relation_metadata do
+          relation.relation_metadata
+        end
+
+        relation.target.define_singleton_method :base do
+          relation.base
+        end
+      end
+    end
+
+    private
+
+    def get_relation(name, metadata, object, reload=false)
+      # has_one and belongs_to will return the value immediately
+      # while other relation are lazy
+      if [Mongoid::Relations::Referenced::In, Mongoid::Relations::Referenced::One].include?(metadata.relation)
+        Mongoload::RelationLoader.load(self, metadata) if !object.is_a?(metadata.klass) && ivar(name) == false
+      end
+
+      result = super
+      result.tap do |relation|
+        Mongoload::RelationsAccessorsWithAutoInclude.assign_missing_proxy_method(relation)
+      end
+    end
+  end
+end
+
+Mongoid::Document.prepend Mongoload::RelationsAccessorsWithAutoInclude

data/lib/mongoload/patches/relations_metadata.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module Mongoload
+  module RelationsMetadataWithOptions
+    def auto_include?
+      fetch(:auto_include, true)
+    end
+
+    def fully_load?
+      fetch(:fully_load, false)
+    end
+  end
+end
+
+::Mongoid::Relations::Metadata.include ::Mongoload::RelationsMetadataWithOptions

data/lib/mongoload/patches/relations_options.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module Mongoload
+  module RelationsOptions
+    MONGOLOAD_OPTIONS = [
+      :auto_include,
+      :fully_load
+    ].freeze
+
+    def validate!(options)
+      options_clone = options.clone
+      MONGOLOAD_OPTIONS.each { |key| options_clone.delete(key) }
+      super(options_clone)
+    end
+  end
+end
+
+class << ::Mongoid::Relations::Options
+  prepend ::Mongoload::RelationsOptions
+end

data/lib/mongoload/patches/relations_targets_enumerable.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module Mongoload
+  module RelationsEnumerableWithAutoInclude
+    # methods which trigger Mongoload only when :fully_load is true
+    # other methods delegated to #target will be processed by #unloaded_documents
+    %w(first last size empty?).each do |method|
+      define_method method do
+        if !_loaded? && relation_metadata.fully_load? && Mongoload::RelationLoader.load(base, relation_metadata)
+          base.ivar(relation_metadata.name).public_send(method)
+        else
+          super()
+        end
+      end
+    end
+
+    private
+
+    # perform eager loading when loading unloaded documents
+    def unloaded_documents
+      if !_loaded? && Mongoload::RelationLoader.load(base, relation_metadata)
+        base.ivar(relation_metadata.name)
+      else
+        super
+      end
+    end
+  end
+end
+
+Mongoid::Relations::Targets::Enumerable.prepend Mongoload::RelationsEnumerableWithAutoInclude

data/lib/mongoload/relation_loader.rb

@@ -16,7 +16,7 @@ module Mongoload
     end
 
     def auto_include?(doc, metadata)
-      relation?(doc, metadata) && !loaded?(doc, metadata)
+      metadata.auto_include? && relation?(doc, metadata) && !loaded?(doc, metadata)
     end
 
     def relation?(doc, metadata)

data/lib/mongoload/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 module Mongoload
   # mongoload version
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

data/spec/db/models.rb

@@ -24,7 +24,7 @@ end
 
 class Tag
   include Mongoid::Document
-  has_and_belongs_to_many :posts
+  has_and_belongs_to_many :posts, fully_load: true
 
   field :name
 end

data/spec/mongoload/mongoload_spec.rb

@@ -11,53 +11,53 @@ describe Mongoload do
   let(:user3) do
     User.create!(username: 'Cathy').tap { |u| u.create_device(uuid: '333') }
   end
+  let(:build_users) { [user1, user2, user3] }
+  let(:users) { User.all.to_a }
+  let(:devices) { Device.all.to_a }
 
   let(:tag1) { Tag.create!(name: 'tag1') }
   let(:tag2) { Tag.create!(name: 'tag2') }
   let(:tag3) { Tag.create!(name: 'tag3') }
   let(:tag4) { Tag.create!(name: 'tag4') }
+  let(:tags) { Tag.all.to_a }
 
   let(:post1) do
     Post.create!(title: 'post1', user: user1).tap do |p|
       p.tags << [tag1, tag2]
     end
   end
-
   let(:post2) do
     Post.create!(title: 'post2', user: user1).tap do |p|
       p.tags << [tag2, tag3]
     end
   end
-
   let(:post3) do
     Post.create!(title: 'post3', user: user2).tap do |p|
       p.tags << [tag1, tag3]
     end
   end
-
   let(:post4) do
     Post.create!(title: 'post4', user: user2).tap do |p|
       p.tags << [tag2, tag4]
     end
   end
-
   let(:post5) do
     Post.create!(title: 'post5', user: user3).tap do |p|
       p.tags << [tag1, tag4]
     end
   end
-
   let(:post6) do
     Post.create!(title: 'post6', user: user3).tap do |p|
       p.tags << [tag2, tag4]
     end
   end
+  let(:build_posts) { [post1, post2, post3, post4, post5, post6] }
+  let(:posts) { Post.all.to_a }
 
   describe 'has_one relation' do
-    before { user1 && user2 && user3 }
+    before { build_users }
 
     it 'should eager load' do
-      users = User.all.to_a
       users.each do |user|
         expect(user.ivar(:device)).to be false
       end
@@ -70,10 +70,9 @@ describe Mongoload do
   end
 
   describe 'has_many relation' do
-    before { post1 && post2 && post3 && post4 && post5 && post6 }
+    before { build_posts }
 
     it 'should eager load' do
-      users = User.all.to_a
       users.each do |user|
         expect(user.posts._loaded?).to be false
       end
@@ -87,10 +86,9 @@ describe Mongoload do
 
   describe 'belongs_to' do
     context 'inverse of has_one' do
-      before { user1 && user2 && user3 }
+      before { build_users }
 
       it 'should eager load' do
-        devices = Device.all.to_a
         devices.each do |device|
           expect(device.ivar(:user)).to be false
         end
@@ -103,10 +101,9 @@ describe Mongoload do
     end
 
     context 'inverse of has_many' do
-      before { post1 && post2 && post3 && post4 && post5 && post6 }
+      before { build_posts }
 
       it 'should eager load' do
-        posts = Post.all.to_a
         posts.each do |post|
           expect(post.ivar(:user)).to be false
         end
@@ -120,10 +117,9 @@ describe Mongoload do
   end
 
   describe 'has_and_belongs_to_many' do
-    before { post1 && post2 && post3 && post4 && post5 && post6 }
+    before { build_posts }
 
     it 'should eager load' do
-      posts = Post.all.to_a
       posts.each do |post|
         expect(post.tags._loaded?).to be false
       end
@@ -134,4 +130,60 @@ describe Mongoload do
       end
     end
   end
+
+  describe 'auto_include' do
+    before { build_users }
+    context 'is set to false' do
+      before do
+        UserWithoutAutoInclude = User.clone
+        UserWithoutAutoInclude.has_one :device, auto_include: false
+      end
+      it 'should not eager load' do
+        users = UserWithoutAutoInclude.all.to_a
+        users.each do |user|
+          expect(user.ivar(:device)).to be false
+        end
+
+        users.first.device
+        users[1..-1].each do |user|
+          expect(user.ivar(:device)).to be false
+        end
+      end
+    end
+  end
+
+  describe 'fully_load' do
+    FULLY_LOAD_METHODS = %w(first last size empty?).freeze
+    before { build_posts }
+
+    context 'is set to true' do
+      FULLY_LOAD_METHODS.each do |method|
+        it "should eager load with ##{method}" do
+          tags.each do |tag|
+            expect(tag.posts._loaded?).to be false
+          end
+
+          tags.first.posts.public_send(method)
+          tags.each do |tag|
+            expect(tag.posts._loaded?).to be true
+          end
+        end
+      end
+    end
+
+    context 'is set to false' do
+      FULLY_LOAD_METHODS.each do |method|
+        it "should not eager load with ##{method}" do
+          posts.each do |post|
+            expect(post.tags._loaded?).to be false
+          end
+
+          posts.first.tags.public_send(method)
+          posts[1..-1].each do |post|
+            expect(post.tags._loaded?).to be false
+          end
+        end
+      end
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mongoload
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - Kaloku Sang
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-04-27 00:00:00.000000000 Z
+date: 2016-04-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongoid
@@ -144,10 +144,12 @@ files:
 - gemfiles/mongoid_master.gemfile
 - lib/mongoload.rb
 - lib/mongoload/auto_include_context.rb
-- lib/mongoload/patches/mongoid_contextual_mongo_patch.rb
-- lib/mongoload/patches/mongoid_document_patch.rb
-- lib/mongoload/patches/mongoid_relations_accessors_patch.rb
-- lib/mongoload/patches/mongoid_relations_targets_enumerable_patch.rb
+- lib/mongoload/patches/contextual_mongo.rb
+- lib/mongoload/patches/document.rb
+- lib/mongoload/patches/relations_accessors.rb
+- lib/mongoload/patches/relations_metadata.rb
+- lib/mongoload/patches/relations_options.rb
+- lib/mongoload/patches/relations_targets_enumerable.rb
 - lib/mongoload/relation_loader.rb
 - lib/mongoload/version.rb
 - log/.keep
@@ -177,7 +179,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.3
+rubygems_version: 2.6.4
 signing_key: 
 specification_version: 4
 summary: Perform eager loading automatically for Mongoid

data/lib/mongoload/patches/mongoid_relations_accessors_patch.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-module Mongoload
-  module MongoRelationsAccessorsWithAutoInclude
-    private
-
-    def get_relation(name, metadata, object, reload=false)
-      # has_one and belongs_to will return the value immediately
-      # while other relation are lazy
-      if [Mongoid::Relations::Referenced::In, Mongoid::Relations::Referenced::One].include?(metadata.relation)
-        Mongoload::RelationLoader.load(self, metadata) if !object.is_a?(metadata.klass) && ivar(name) == false
-      end
-
-      result = super
-      result.tap do |relation|
-        if relation.class == Mongoid::Relations::Targets::Enumerable
-          relation.target.define_singleton_method :relation_metadata do
-            relation.relation_metadata
-          end
-
-          relation.target.define_singleton_method :base do
-            relation.base
-          end
-        end
-      end
-    end
-  end
-end
-
-Mongoid::Document.prepend Mongoload::MongoRelationsAccessorsWithAutoInclude

data/lib/mongoload/patches/mongoid_relations_targets_enumerable_patch.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-module Mongoload
-  module MongoRelationsEnumerableWithAutoInclude
-    private
-
-    def unloaded_documents
-      if Mongoload::RelationLoader.load(base, relation_metadata)
-        base.ivar(relation_metadata.name)
-      else
-        super
-      end
-    rescue NotImplementedError
-      super
-    end
-  end
-end
-
-Mongoid::Relations::Targets::Enumerable.prepend Mongoload::MongoRelationsEnumerableWithAutoInclude