mongoid-scroll 1.0.1 → 2.0.1

data/spec/spec_helper.rb

@@ -1,12 +1,23 @@
 $LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
 $LOAD_PATH.unshift(File.dirname(__FILE__))
 
+if ENV['COVERAGE'] == 'true'
+  require 'simplecov'
+  SimpleCov.start do
+    track_files 'lib/**/*.rb'
+    add_filter '/spec/'
+  end
+end
+
 require 'rubygems'
 require 'rspec'
 require 'rspec/its'
-require 'database_cleaner'
+require 'logger'
+require 'database_cleaner/mongoid'
 require 'mongoid-scroll'
 
+Time.zone ||= 'EST'
+
 Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each do |f|
   require f
 end
@@ -18,9 +29,9 @@ end
 RSpec.configure do |config|
   config.before :all do
     Mongoid.logger.level = Logger::INFO
-    Mongo::Logger.logger.level = Logger::INFO if Mongoid::Compatibility::Version.mongoid5_or_newer?
+    Mongo::Logger.logger.level = Logger::INFO
   end
-  config.before :each do
+  config.before do
     DatabaseCleaner.clean
   end
 end

data/spec/support/feed/embedded_item.rb

@@ -1,3 +1,5 @@
+require_relative 'item'
+
 module Feed
   class EmbeddedItem
     include Mongoid::Document

data/spec/support/feed/item.rb

@@ -13,7 +13,7 @@ module Feed
     embeds_many :embedded_items, class_name: 'Feed::EmbeddedItem'
 
     publisher_options = { class_name: 'Feed::Publisher' }
-    publisher_options[:optional] = true if Mongoid::Compatibility::Version.mongoid6_or_newer?
+    publisher_options[:optional] = true
     belongs_to :publisher, publisher_options
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-scroll
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 2.0.1
 platform: ruby
 authors:
 - Daniel Doubrovkine
@@ -9,24 +9,10 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-03-15 00:00:00.000000000 Z
+date: 2026-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: mongoid
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.0'
-- !ruby/object:Gem::Dependency
-  name: mongoid-compatibility
+  name: i18n
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -40,19 +26,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: i18n
+  name: mongoid
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '6.0'
 description:
 email: dblock@dblock.org
 executables: []
@@ -60,6 +46,7 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".github/workflows/ci.yml"
+- ".github/workflows/danger-comment.yml"
 - ".github/workflows/danger.yml"
 - ".gitignore"
 - ".rspec"
@@ -73,14 +60,13 @@ files:
 - RELEASING.md
 - Rakefile
 - UPGRADING.md
-- examples/mongo_ruby_driver_scroll_feed.rb
-- examples/mongoid_scroll_feed.rb
+- examples/feed.rb
 - lib/config/locales/en.yml
-- lib/mongo/scrollable.rb
 - lib/mongoid-scroll.rb
 - lib/mongoid/criteria/scrollable.rb
 - lib/mongoid/criteria/scrollable/cursors.rb
 - lib/mongoid/criteria/scrollable/fields.rb
+- lib/mongoid/criteria/scrollable/iterator.rb
 - lib/mongoid/scroll/base64_encoded_cursor.rb
 - lib/mongoid/scroll/base_cursor.rb
 - lib/mongoid/scroll/cursor.rb
@@ -93,10 +79,10 @@ files:
 - lib/mongoid/scroll/errors/multiple_sort_fields_error.rb
 - lib/mongoid/scroll/errors/no_such_field_error.rb
 - lib/mongoid/scroll/errors/unsupported_field_type_error.rb
+- lib/mongoid/scroll/errors/unsupported_type_error.rb
 - lib/mongoid/scroll/version.rb
 - lib/mongoid_scroll.rb
 - mongoid-scroll.gemspec
-- spec/mongo/collection_view_spec.rb
 - spec/mongoid/base64_encoded_cursor_spec.rb
 - spec/mongoid/criteria_spec.rb
 - spec/mongoid/cursor_spec.rb
@@ -109,7 +95,8 @@ files:
 homepage: http://github.com/mongoid/mongoid-scroll
 licenses:
 - MIT
-metadata: {}
+metadata:
+  rubygems_mfa_required: 'true'
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -125,7 +112,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: Mongoid extensions to enable infinite scroll.

data/examples/mongo_ruby_driver_scroll_feed.rb

@@ -1,45 +0,0 @@
-require 'bundler'
-Bundler.setup(:default, :development)
-
-require 'mongoid-scroll'
-require 'faker'
-
-raise 'No Mongo Ruby Driver' unless Object.const_defined?(:Mongo)
-
-Mongo::Logger.logger = Logger.new($stdout)
-Mongo::Logger.logger.level = Logger::INFO
-
-Mongoid.connect_to 'mongoid_scroll_demo'
-Mongoid.purge!
-
-# 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_client['feed_items'].insert_one(title: Faker::Lorem.sentence, position: rands.pop)
-end
-
-Mongoid.default_client['feed_items'].indexes.create_one(position: 1, _id: 1)
-
-total_shown = 0
-next_cursor = nil
-loop do
-  current_cursor = next_cursor
-  next_cursor = nil
-  Mongoid.default_client['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_client['feed_items'].find.sort(position: 1).first
-  Mongoid.default_client['feed_items'].find(_id: item['_id']).delete_one
-end
-
-# this will be 20
-puts "Shown #{total_shown} items."

data/lib/mongo/scrollable.rb

@@ -1,39 +0,0 @@
-module Mongo
-  module Scrollable
-    include Mongoid::Criteria::Scrollable::Fields
-    include Mongoid::Criteria::Scrollable::Cursors
-
-    def scroll(cursor_or_type = nil, options = nil, &_block)
-      cursor, cursor_type = cursor_and_type(cursor_or_type)
-      view = self
-      # we don't support scrolling over a view with multiple fields
-      raise Mongoid::Scroll::Errors::MultipleSortFieldsError.new(sort: view.sort) if view.sort && view.sort.keys.size != 1
-      # scroll field and direction
-      scroll_field = view.sort ? view.sort.keys.first : :_id
-      scroll_direction = view.sort ? view.sort.values.first.to_i : 1
-      # scroll cursor from the parameter, with value and tiebreak_id
-      options = { field_type: BSON::ObjectId } unless options
-      cursor_options = { field_name: scroll_field, direction: scroll_direction }.merge(options)
-      cursor = cursor && cursor.is_a?(cursor_type) ? cursor : cursor_type.new(cursor, cursor_options)
-      raise_mismatched_sort_fields_error!(cursor, cursor_options) if different_sort_fields?(cursor, cursor_options)
-      # make a view
-      view = Mongo::Collection::View.new(
-        view.collection,
-        view.selector.merge(cursor.criteria),
-        sort: (view.sort || {}).merge(_id: scroll_direction),
-        skip: skip,
-        limit: limit
-      )
-      # scroll
-      if block_given?
-        view.each do |record|
-          yield record, cursor_type.from_record(record, cursor_options)
-        end
-      else
-        view
-      end
-    end
-  end
-end
-
-Mongo::Collection::View.send(:include, Mongo::Scrollable)

data/spec/mongo/collection_view_spec.rb

@@ -1,143 +0,0 @@
-require 'spec_helper'
-
-if Object.const_defined?(:Mongo)
-  describe Mongo::Collection::View do
-    [Mongoid::Scroll::Cursor, Mongoid::Scroll::Base64EncodedCursor].each do |cursor_type|
-      context cursor_type do
-        context 'scrollable' do
-          subject do
-            Mongoid.default_client['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_client['feed_items'].find.sort(name: 1, value: -1)
-          end
-          it 'raises Mongoid::Scroll::Errors::MultipleSortFieldsError' do
-            expect { subject.scroll(cursor_type) }.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 different sort fields between the cursor and the criteria' do
-          subject do
-            Mongoid.default_client['feed_items'].find.sort(name: -1)
-          end
-
-          it 'raises Mongoid::Scroll::Errors::MismatchedSortFieldsError' do
-            record = Feed::Item.create!
-            cursor = cursor_type.from_record(record, field: record.fields['a_string'])
-            expect(cursor).to be_a cursor_type
-            error_string = /You're attempting to scroll over data with a sort order that differs between the cursor and the original criteria: field_name, direction./
-            expect { subject.scroll(cursor, field_type: String) }.to raise_error Mongoid::Scroll::Errors::MismatchedSortFieldsError, error_string
-          end
-        end
-        context 'with no sort' do
-          subject do
-            Mongoid.default_client['feed_items'].find
-          end
-          it 'adds a default sort by _id' do
-            expect(subject.scroll(cursor_type).sort).to eq('_id' => 1)
-          end
-        end
-        context 'with data' do
-          before :each do
-            10.times do |i|
-              Mongoid.default_client['feed_items'].insert_one(
-                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_client['feed_items'].find.scroll(cursor_type) do |record, _next_cursor|
-                records << record
-              end
-              expect(records.size).to eq 10
-              expect(records).to eq Mongoid.default_client['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_client['feed_items'].find.sort(field_name => 1).scroll(cursor_type, field_type: field_type) do |record, _next_cursor|
-                  records << record
-                end
-                expect(records.size).to eq 10
-                expect(records).to eq Mongoid.default_client['feed_items'].find.to_a
-              end
-              it 'scrolls all with a break' do
-                records = []
-                cursor = nil
-                Mongoid.default_client['feed_items'].find.sort(field_name => 1).limit(5).scroll(cursor_type, field_type: field_type) do |record, next_cursor|
-                  records << record
-                  cursor = next_cursor
-                  expect(cursor).to be_a cursor_type
-                end
-                expect(records.size).to eq 5
-                Mongoid.default_client['feed_items'].find.sort(field_name => 1).scroll(cursor, field_type: field_type) do |record, next_cursor|
-                  records << record
-                  cursor = next_cursor
-                  expect(cursor).to be_a cursor_type
-                end
-                expect(records.size).to eq 10
-                expect(records).to eq Mongoid.default_client['feed_items'].find.to_a
-              end
-              it 'scrolls in descending order' do
-                records = []
-                Mongoid.default_client['feed_items'].find.sort(field_name => -1).limit(3).scroll(cursor_type, 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_client['feed_items'].find.sort(field_name => -1).limit(3).to_a
-              end
-              it 'map' do
-                record = Mongoid.default_client['feed_items'].find.limit(3).scroll(cursor_type, field_type: field_type, field_name: field_name).map { |r| r }.last
-                cursor = cursor_type.from_record(record, field_type: field_type, field_name: field_name)
-                expect(cursor).to_not be nil
-                expect(cursor.value).to eq record[field_name.to_s]
-                expect(cursor.tiebreak_id).to eq record['_id']
-              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_client['feed_items'].find.sort(sort_order).limit(2).scroll(cursor_type) do |record, next_cursor|
-                records << record
-                cursor = next_cursor
-              end
-              expect(records.size).to eq 2
-              Mongoid.default_client['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_client['feed_items'].find.sort(sort_order.merge(_id: sort_order[:a_integer])).to_a
-            end
-          end
-        end
-      end
-    end
-  end
-end