mongoid-scroll 0.3.7 → 1.0.0

data/examples/moped_scroll_feed.rb

@@ -1,45 +0,0 @@
-require 'bundler'
-Bundler.setup(:default, :development)
-
-require 'mongoid-scroll'
-require 'faker'
-
-Mongoid.connect_to 'mongoid_scroll_demo'
-Mongoid.purge!
-
-raise 'No Moped' unless Object.const_defined?(:Moped)
-
-# total items to insert
-total_items = 20
-# a MongoDB query will be executed every scroll_by items
-scroll_by = 7
-
-# insert items with a position out-of-order
-rands = (0..total_items).to_a.sort { rand }[0..total_items]
-total_items.times do
-  Mongoid.default_session['feed_items'].insert(title: Faker::Lorem.sentence, position: rands.pop)
-end
-
-Mongoid.default_session['feed_items'].indexes.create(position: 1, _id: 1)
-
-Moped.logger = Logger.new($stdout)
-Moped.logger.level = Logger::DEBUG
-
-total_shown = 0
-next_cursor = nil
-loop do
-  current_cursor = next_cursor
-  next_cursor = nil
-  Mongoid.default_session['feed_items'].find.limit(scroll_by).sort(position: 1).scroll(current_cursor, field_type: Integer, field_name: 'position') do |item, cursor|
-    puts "#{item['position']}: #{item['title']}"
-    next_cursor = cursor
-    total_shown += 1
-  end
-  break unless next_cursor
-  # destroy an item just for the heck of it, scroll is not affected
-  item = Mongoid.default_session['feed_items'].find.sort(position: 1).first
-  Mongoid.default_session['feed_items'].find(_id: item['_id']).remove
-end
-
-# this will be 20
-puts "Shown #{total_shown} items."

data/lib/moped/scrollable.rb

@@ -1,38 +0,0 @@
-module Moped
-  module Scrollable
-    def scroll(cursor = nil, options = nil, &_block)
-      unless options
-        bson_type = Mongoid::Compatibility::Version.mongoid3? ? Moped::BSON::ObjectId : BSON::ObjectId
-        options = { field_type: bson_type }
-      end
-      query = Query.new(collection, operation.selector.dup)
-      query.operation.skip = operation.skip
-      query.operation.limit = operation.limit
-      # we don't support scrolling over a criteria with multiple fields
-      if query.operation.selector['$orderby'] && query.operation.selector['$orderby'].keys.size != 1
-        raise Mongoid::Scroll::Errors::MultipleSortFieldsError.new(sort: query.operation.selector['$orderby'])
-      elsif !query.operation.selector.key?('$orderby') || query.operation.selector['$orderby'].empty?
-        # introduce a default sort order if there's none
-        query.sort(_id: 1)
-      end
-      # scroll field and direction
-      scroll_field = query.operation.selector['$orderby'].keys.first
-      scroll_direction = query.operation.selector['$orderby'].values.first.to_i
-      # scroll cursor from the parameter, with value and tiebreak_id
-      cursor_options = { field_name: scroll_field, field_type: options[:field_type], direction: scroll_direction }
-      cursor = cursor.is_a?(Mongoid::Scroll::Cursor) ? cursor : Mongoid::Scroll::Cursor.new(cursor, cursor_options)
-      query.operation.selector['$query'] = query.operation.selector['$query'].merge(cursor.criteria)
-      query.operation.selector['$orderby'] = query.operation.selector['$orderby'].merge(_id: scroll_direction)
-      # scroll
-      if block_given?
-        query.each do |record|
-          yield record, Mongoid::Scroll::Cursor.from_record(record, cursor_options)
-        end
-      else
-        query
-      end
-    end
-  end
-end
-
-Moped::Query.send(:include, Moped::Scrollable)

data/spec/moped/query_spec.rb

@@ -1,126 +0,0 @@
-require 'spec_helper'
-
-if Object.const_defined?(:Moped)
-  describe Moped::Query do
-    context 'scrollable' do
-      subject do
-        Mongoid.default_session['feed_items'].find
-      end
-      it ':scroll' do
-        expect(subject).to respond_to(:scroll)
-      end
-    end
-    context 'with multiple sort fields' do
-      subject do
-        Mongoid.default_session['feed_items'].find.sort(name: 1, value: -1)
-      end
-      it 'raises Mongoid::Scroll::Errors::MultipleSortFieldsError' do
-        expect { subject.scroll }.to raise_error Mongoid::Scroll::Errors::MultipleSortFieldsError,
-                                                 /You're attempting to scroll over data with a sort order that includes multiple fields: name, value./
-      end
-    end
-    context 'with no sort' do
-      subject do
-        Mongoid.default_session['feed_items'].find
-      end
-      it 'adds a default sort by _id' do
-        expect(subject.scroll.operation.selector['$orderby']).to eq(_id: 1)
-      end
-    end
-    context 'with data' do
-      before :each do
-        10.times do |i|
-          Mongoid.default_session['feed_items'].insert(
-            a_string: i.to_s,
-            a_integer: i,
-            a_datetime: DateTime.mongoize(DateTime.new(2013, i + 1, 21, 1, 42, 3, 'UTC')),
-            a_date: Date.mongoize(Date.new(2013, i + 1, 21)),
-            a_time: Time.mongoize(Time.at(Time.now.to_i + i))
-          )
-        end
-      end
-      context 'default' do
-        it 'scrolls all' do
-          records = []
-          Mongoid.default_session['feed_items'].find.scroll do |record, _next_cursor|
-            records << record
-          end
-          expect(records.size).to eq 10
-          expect(records).to eq Mongoid.default_session['feed_items'].find.to_a
-        end
-      end
-      { a_string: String, a_integer: Integer, a_date: Date, a_datetime: DateTime }.each_pair do |field_name, field_type|
-        context field_type do
-          it 'scrolls all with a block' do
-            records = []
-            Mongoid.default_session['feed_items'].find.sort(field_name => 1).scroll(nil, field_type: field_type) do |record, _next_cursor|
-              records << record
-            end
-            expect(records.size).to eq 10
-            expect(records).to eq Mongoid.default_session['feed_items'].find.to_a
-          end
-          it 'scrolls all with a break' do
-            records = []
-            cursor = nil
-            Mongoid.default_session['feed_items'].find.sort(field_name => 1).limit(5).scroll(nil, field_type: field_type) do |record, next_cursor|
-              records << record
-              cursor = next_cursor
-            end
-            expect(records.size).to eq 5
-            Mongoid.default_session['feed_items'].find.sort(field_name => 1).scroll(cursor, field_type: field_type) do |record, next_cursor|
-              records << record
-              cursor = next_cursor
-            end
-            expect(records.size).to eq 10
-            expect(records).to eq Mongoid.default_session['feed_items'].find.to_a
-          end
-          it 'scrolls in descending order' do
-            records = []
-            Mongoid.default_session['feed_items'].find.sort(field_name => -1).limit(3).scroll(nil, field_type: field_type, field_name: field_name) do |record, _next_cursor|
-              records << record
-            end
-            expect(records.size).to eq 3
-            expect(records).to eq Mongoid.default_session['feed_items'].find.sort(field_name => -1).limit(3).to_a
-          end
-          it 'map' do
-            record = Mongoid.default_session['feed_items'].find.limit(3).scroll(nil, field_type: field_type, field_name: field_name).map { |r| r }.last
-            cursor = Mongoid::Scroll::Cursor.from_record(record, field_type: field_type, field_name: field_name)
-            expect(cursor).to_not be nil
-            expect(cursor.to_s.split(':')).to eq [
-              Mongoid::Scroll::Cursor.transform_field_value(field_type, field_name, record[field_name.to_s]).to_s,
-              record['_id'].to_s
-            ]
-          end
-        end
-      end
-    end
-    context 'with overlapping data', if: MongoDB.mmapv1? do
-      before :each do
-        3.times { Feed::Item.create! a_integer: 5 }
-        Feed::Item.first.update_attributes!(name: Array(1000).join('a'))
-      end
-      it 'natural order is different from order by id' do
-        # natural order isn't necessarily going to be the same as _id order
-        # if a document is updated and grows in size, it may need to be relocated and
-        # thus cause the natural order to change
-        expect(Feed::Item.order_by('$natural' => 1).to_a).to_not eq Feed::Item.order_by(_id: 1).to_a
-      end
-      [{ a_integer: 1 }, { a_integer: -1 }].each do |sort_order|
-        it "scrolls by #{sort_order}" do
-          records = []
-          cursor = nil
-          Mongoid.default_session['feed_items'].find.sort(sort_order).limit(2).scroll do |record, next_cursor|
-            records << record
-            cursor = next_cursor
-          end
-          expect(records.size).to eq 2
-          Mongoid.default_session['feed_items'].find.sort(sort_order).scroll(cursor) do |record, _next_cursor|
-            records << record
-          end
-          expect(records.size).to eq 3
-          expect(records).to eq Mongoid.default_session['feed_items'].find.sort(sort_order.merge(_id: sort_order[:a_integer])).to_a
-        end
-      end
-    end
-  end
-end