mongoid-scroll 1.0.1 → 2.0.0

data/lib/mongoid/criteria/scrollable.rb

@@ -10,15 +10,24 @@ module Mongoid
         criteria = dup
         criteria.merge!(default_sort) if no_sort_option?
         cursor_options = build_cursor_options(criteria)
-        cursor = cursor.is_a?(cursor_type) ? cursor : new_cursor(cursor_type, cursor, cursor_options)
+        cursor = new_cursor(cursor_type, cursor, cursor_options) unless cursor.is_a?(cursor_type)
         raise_mismatched_sort_fields_error!(cursor, cursor_options) if different_sort_fields?(cursor, cursor_options)
-        cursor_criteria = build_cursor_criteria(criteria, cursor)
+        records = find_records(criteria, cursor)
         if block_given?
-          cursor_criteria.order_by(_id: scroll_direction(criteria)).each do |record|
-            yield record, cursor_from_record(cursor_type, record, cursor_options)
+          previous_cursor = nil
+          current_cursor = nil
+          records.each do |record|
+            previous_cursor ||= cursor_from_record(cursor_type, record, cursor_options.merge(type: :previous))
+            current_cursor ||= cursor_from_record(cursor_type, record, cursor_options.merge(include_current: true))
+            iterator = Mongoid::Criteria::Scrollable::Iterator.new(
+              previous_cursor: previous_cursor,
+              next_cursor: cursor_from_record(cursor_type, record, cursor_options),
+              current_cursor: current_cursor
+            )
+            yield record, iterator
           end
         else
-          cursor_criteria
+          records
         end
       end
 
@@ -60,10 +69,21 @@ module Mongoid
         cursor_type.new(cursor, cursor_options)
       end
 
-      def build_cursor_criteria(criteria, cursor)
+      def find_records(criteria, cursor)
         cursor_criteria = criteria.dup
         cursor_criteria.selector = { '$and' => [criteria.selector, cursor.criteria] }
-        cursor_criteria
+        if cursor.type == :previous
+          pipeline = [
+            { '$match' => cursor_criteria.selector },
+            { '$sort' => { cursor.field_name => -cursor.direction } },
+            { '$limit' => criteria.options[:limit] },
+            { '$sort' => { cursor.field_name => cursor.direction } }
+          ]
+          aggregation = cursor_criteria.view.aggregate(pipeline)
+          aggregation.map { |record| Mongoid::Factory.from_db(cursor_criteria.klass, record) }
+        else
+          cursor_criteria.order_by(_id: scroll_direction(criteria))
+        end
       end
 
       def cursor_from_record(cursor_type, record, cursor_options)
@@ -79,4 +99,4 @@ module Mongoid
   end
 end
 
-Mongoid::Criteria.send(:include, Mongoid::Criteria::Scrollable)
+Mongoid::Criteria.include Mongoid::Criteria::Scrollable

data/lib/mongoid/scroll/base64_encoded_cursor.rb

@@ -10,18 +10,19 @@ module Mongoid
         if value
           begin
             parsed = ::JSON.parse(::Base64.strict_decode64(value))
-          rescue
+          rescue StandardError
             raise Mongoid::Scroll::Errors::InvalidBase64CursorError.new(cursor: value)
           end
-          super parse_field_value(parsed['field_type'], parsed['field_name'], parsed['value']), {
+          super(parse_field_value(parsed['field_type'], parsed['field_name'], parsed['value']), {
             field_type: parsed['field_type'],
             field_name: parsed['field_name'],
             direction: parsed['direction'],
             include_current: parsed['include_current'],
-            tiebreak_id: parsed['tiebreak_id'] && !parsed['tiebreak_id'].empty? ? BSON::ObjectId.from_string(parsed['tiebreak_id']) : nil
-          }
+            tiebreak_id: parsed['tiebreak_id'] && !parsed['tiebreak_id'].empty? ? BSON::ObjectId.from_string(parsed['tiebreak_id']) : nil,
+            type: parsed['type'].try(:to_sym)
+          })
         else
-          super nil, options
+          super(nil, options)
         end
       end
 
@@ -32,7 +33,8 @@ module Mongoid
           field_name: field_name,
           direction: direction,
           include_current: include_current,
-          tiebreak_id: tiebreak_id && tiebreak_id.to_s
+          tiebreak_id: tiebreak_id && tiebreak_id.to_s,
+          type: type
         }.to_json)
       end
     end

data/lib/mongoid/scroll/base_cursor.rb

@@ -1,7 +1,7 @@
 module Mongoid
   module Scroll
     class BaseCursor
-      attr_accessor :value, :tiebreak_id, :field_type, :field_name, :direction, :include_current
+      attr_accessor :value, :tiebreak_id, :field_type, :field_name, :direction, :include_current, :type
 
       def initialize(value, options = {})
         @value = value
@@ -10,17 +10,16 @@ module Mongoid
         @field_name = options[:field_name]
         @direction = options[:direction] || 1
         @include_current = options[:include_current] || false
+        @type = options[:type] || :next
+
+        raise Mongoid::Scroll::Errors::UnsupportedTypeError.new(type: @type) unless %i[previous next].include?(@type)
       end
 
       def criteria
         mongo_value = value.class.mongoize(value) if value
         cursor_criteria = { field_name => { compare_direction => mongo_value } } if mongo_value
         tiebreak_criteria = { field_name => mongo_value, :_id => { tiebreak_compare_direction => tiebreak_id } } if mongo_value && tiebreak_id
-        cursor_selector = if Mongoid::Compatibility::Version.mongoid6_or_newer?
-                            Mongoid::Criteria::Queryable::Selector.new
-                          else
-                            Origin::Selector.new
-                          end
+        cursor_selector = Mongoid::Criteria::Queryable::Selector.new
         cursor_selector['$or'] = [cursor_criteria, tiebreak_criteria].compact if cursor_criteria || tiebreak_criteria
         cursor_selector.__evolve_object_id__
       end
@@ -69,8 +68,7 @@ module Mongoid
         return nil unless value
 
         case field_type.to_s
-        when 'BSON::ObjectId' then value.to_s
-        when 'String' then value.to_s
+        when 'BSON::ObjectId', 'String' then value.to_s
         when 'Date' then Time.utc(value.year, value.month, value.day).to_i
         when 'DateTime', 'Time' then value.utc.to_f.round(3)
         when 'Float' then value.to_f
@@ -86,20 +84,23 @@ module Mongoid
             field_type: field_type.to_s,
             field_name: field_name.to_s,
             direction: options[:direction] || 1,
-            include_current: options[:include_current] || false
+            include_current: options[:include_current] || false,
+            type: options[:type].try(:to_sym) || :next
           }
         elsif options && (field = options[:field])
           {
             field_type: field.type.to_s,
             field_name: field.name.to_s,
             direction: options[:direction] || 1,
-            include_current: options[:include_current] || false
+            include_current: options[:include_current] || false,
+            type: options[:type].try(:to_sym) || :next
           }
         end
       end
 
       def compare_direction
-        direction == 1 ? '$gt' : '$lt'
+        dir = type == :previous ? -direction : direction
+        dir == 1 ? '$gt' : '$lt'
       end
 
       def tiebreak_compare_direction

data/lib/mongoid/scroll/cursor.rb

@@ -4,20 +4,20 @@ module Mongoid
       def initialize(value = nil, options = {})
         options = extract_field_options(options)
         raise ArgumentError.new 'Missing options[:field_name] and/or options[:field_type].' unless options
+
         if value
           parts = value.split(':') if value
-          unless parts && parts.length >= 2
-            raise Mongoid::Scroll::Errors::InvalidCursorError.new(cursor: value)
-          end
+          raise Mongoid::Scroll::Errors::InvalidCursorError.new(cursor: value) unless parts && parts.length >= 2
+
           value = parse_field_value(
             options[:field_type],
             options[:field_name],
             parts[0...-1].join(':')
           )
           options[:tiebreak_id] = BSON::ObjectId.from_string(parts[-1])
-          super value, options
+          super
         else
-          super nil, options
+          super(nil, options)
         end
       end
 

data/lib/mongoid/scroll/errors/base.rb

@@ -21,13 +21,13 @@ module Mongoid
           @resolution = create_resolution(key, attributes)
 
           "\nProblem:\n  #{@problem}" \
-          "\nSummary:\n  #{@summary}" \
-          "\nResolution:\n  #{@resolution}"
+            "\nSummary:\n  #{@summary}" \
+            "\nResolution:\n  #{@resolution}"
         end
 
         private
 
-        BASE_KEY = 'mongoid.scroll.errors.messages'.freeze #:nodoc:
+        BASE_KEY = 'mongoid.scroll.errors.messages'.freeze # :nodoc:
 
         # Given the key of the specific error and the options hash, translate the
         # message.
@@ -38,7 +38,7 @@ module Mongoid
         #
         # Returns a localized error message string.
         def translate(key, options)
-          ::I18n.translate("#{BASE_KEY}.#{key}", **{ locale: :en }.merge(options)).strip
+          ::I18n.translate("#{BASE_KEY}.#{key}", locale: :en, **options).strip
         end
 
         # Create the problem.

data/lib/mongoid/scroll/errors/mismatched_sort_fields_error.rb

@@ -4,9 +4,7 @@ module Mongoid
       # Raised when the original sort params and the cursor sort params are different
       class MismatchedSortFieldsError < Mongoid::Scroll::Errors::Base
         def initialize(opts = {})
-          if opts[:diff] && opts[:diff].is_a?(Hash)
-            opts = opts.merge(diff: opts[:diff].keys.join(', '))
-          end
+          opts = opts.merge(diff: opts[:diff].keys.join(', ')) if opts[:diff] && opts[:diff].is_a?(Hash)
           super(compose_message('mismatched_sort_fields', opts))
         end
       end

data/lib/mongoid/scroll/errors/multiple_sort_fields_error.rb

@@ -3,9 +3,7 @@ module Mongoid
     module Errors
       class MultipleSortFieldsError < Mongoid::Scroll::Errors::Base
         def initialize(opts = {})
-          if opts[:sort] && opts[:sort].is_a?(Hash)
-            opts = opts.merge(sort: opts[:sort].keys.join(', '))
-          end
+          opts = opts.merge(sort: opts[:sort].keys.join(', ')) if opts[:sort] && opts[:sort].is_a?(Hash)
           super(compose_message('multiple_sort_fields', opts))
         end
       end

data/lib/mongoid/scroll/errors/unsupported_type_error.rb

@@ -0,0 +1,11 @@
+module Mongoid
+  module Scroll
+    module Errors
+      class UnsupportedTypeError < Mongoid::Scroll::Errors::Base
+        def initialize(opts = {})
+          super(compose_message('unsupported_type', opts))
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/scroll/errors.rb

@@ -6,3 +6,4 @@ require 'mongoid/scroll/errors/invalid_cursor_error'
 require 'mongoid/scroll/errors/invalid_base64_cursor_error'
 require 'mongoid/scroll/errors/no_such_field_error'
 require 'mongoid/scroll/errors/unsupported_field_type_error'
+require 'mongoid/scroll/errors/unsupported_type_error'

data/lib/mongoid/scroll/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module Scroll
-    VERSION = '1.0.1'.freeze
+    VERSION = '2.0.0'.freeze
   end
 end

data/lib/mongoid-scroll.rb

@@ -3,7 +3,6 @@ require 'i18n'
 I18n.load_path << File.join(File.dirname(__FILE__), 'config', 'locales', 'en.yml')
 
 require 'mongoid'
-require 'mongoid-compatibility'
 require 'mongoid/scroll/version'
 require 'mongoid/scroll/errors'
 require 'mongoid/scroll/base_cursor'
@@ -11,5 +10,5 @@ require 'mongoid/scroll/cursor'
 require 'mongoid/scroll/base64_encoded_cursor'
 require 'mongoid/criteria/scrollable/fields'
 require 'mongoid/criteria/scrollable/cursors'
-require 'mongo/scrollable' if Object.const_defined?(:Mongo)
+require 'mongoid/criteria/scrollable/iterator'
 require 'mongoid/criteria/scrollable'

data/mongoid-scroll.gemspec

@@ -1,4 +1,4 @@
-$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+$LOAD_PATH.push File.expand_path('lib', __dir__)
 require 'mongoid/scroll/version'
 
 Gem::Specification.new do |s|
@@ -13,7 +13,7 @@ Gem::Specification.new do |s|
   s.homepage = 'http://github.com/mongoid/mongoid-scroll'
   s.licenses = ['MIT']
   s.summary = 'Mongoid extensions to enable infinite scroll.'
-  s.add_dependency 'mongoid', '>= 3.0'
-  s.add_dependency 'mongoid-compatibility'
   s.add_dependency 'i18n'
+  s.add_dependency 'mongoid', '>= 6.0'
+  s.metadata['rubygems_mfa_required'] = 'true'
 end

data/spec/mongoid/base64_encoded_cursor_spec.rb

@@ -3,17 +3,25 @@ require 'spec_helper'
 describe Mongoid::Scroll::Base64EncodedCursor do
   context 'new' do
     context 'an empty cursor' do
-      let(:base64_string) { 'eyJ2YWx1ZSI6bnVsbCwiZmllbGRfdHlwZSI6IlN0cmluZyIsImZpZWxkX25hbWUiOiJhX3N0cmluZyIsImRpcmVjdGlvbiI6MSwiaW5jbHVkZV9jdXJyZW50IjpmYWxzZSwidGllYnJlYWtfaWQiOm51bGx9' }
       subject do
         Mongoid::Scroll::Base64EncodedCursor.new base64_string
       end
-      its(:tiebreak_id) { should be_nil }
-      its(:value) { should be_nil }
-      its(:criteria) { should eq({}) }
-      its(:to_s) { should eq(base64_string) }
+
+      let(:base64_string) { 'eyJ2YWx1ZSI6bnVsbCwiZmllbGRfdHlwZSI6IlN0cmluZyIsImZpZWxkX25hbWUiOiJhX3N0cmluZyIsImRpcmVjdGlvbiI6MSwiaW5jbHVkZV9jdXJyZW50IjpmYWxzZSwidGllYnJlYWtfaWQiOm51bGwsInR5cGUiOiJuZXh0In0=' }
+
+      its(:tiebreak_id) { is_expected.to be_nil }
+      its(:value) { is_expected.to be_nil }
+      its(:criteria) { is_expected.to eq({}) }
+      its(:type) { is_expected.to eq(:next) }
+      its(:to_s) { is_expected.to eq(base64_string) }
     end
+
     context 'a string field cursor' do
-      let(:base64_string) { 'eyJ2YWx1ZSI6ImEgc3RyaW5nIiwiZmllbGRfdHlwZSI6IlN0cmluZyIsImZpZWxkX25hbWUiOiJhX3N0cmluZyIsImRpcmVjdGlvbiI6MSwiaW5jbHVkZV9jdXJyZW50IjpmYWxzZSwidGllYnJlYWtfaWQiOiI2NDA2M2RmODA5NDQzNDE3YzdkMmIxMDIifQ==' }
+      subject do
+        Mongoid::Scroll::Base64EncodedCursor.new base64_string
+      end
+
+      let(:base64_string) { 'eyJ2YWx1ZSI6ImEgc3RyaW5nIiwiZmllbGRfdHlwZSI6IlN0cmluZyIsImZpZWxkX25hbWUiOiJhX3N0cmluZyIsImRpcmVjdGlvbiI6MSwiaW5jbHVkZV9jdXJyZW50IjpmYWxzZSwidGllYnJlYWtfaWQiOiI2NDA2M2RmODA5NDQzNDE3YzdkMmIxMDIiLCJ0eXBlIjoibmV4dCJ9' }
       let(:a_value) { 'a string' }
       let(:tiebreak_id) { BSON::ObjectId.from_string('64063df809443417c7d2b102') }
       let(:criteria) do
@@ -24,18 +32,24 @@ describe Mongoid::Scroll::Base64EncodedCursor do
           ]
         }
       end
-      subject do
-        Mongoid::Scroll::Base64EncodedCursor.new base64_string
-      end
-      its(:value) { should eq a_value }
+
+      its(:value) { is_expected.to eq a_value }
       its(:tiebreak_id) { tiebreak_id }
-      its(:value) { should eq a_value }
-      its(:tiebreak_id) { should eq tiebreak_id }
-      its(:criteria) { should eq(criteria) }
-      its(:to_s) { should eq(base64_string) }
+      its(:value) { is_expected.to eq a_value }
+      its(:tiebreak_id) { is_expected.to eq tiebreak_id }
+      its(:criteria) { is_expected.to eq(criteria) }
+      its(:type) { is_expected.to eq(:next) }
+      its(:to_s) { is_expected.to eq(base64_string) }
     end
+
     context 'an id field cursor' do
-      let(:base64_string) { 'eyJ2YWx1ZSI6IjY0MDY0NTg0MDk0NDM0MjgxZmE3MWFiMiIsImZpZWxkX3R5cGUiOiJCU09OOjpPYmplY3RJZCIsImZpZWxkX25hbWUiOiJpZCIsImRpcmVjdGlvbiI6MSwiaW5jbHVkZV9jdXJyZW50IjpmYWxzZSwidGllYnJlYWtfaWQiOiI2NDA2NDU4NDA5NDQzNDI4MWZhNzFhYjIifQ==' }
+      subject do
+        Mongoid::Scroll::Base64EncodedCursor.new base64_string
+      end
+
+      let(:base64_string) do
+        'eyJ2YWx1ZSI6IjY0MDY0NTg0MDk0NDM0MjgxZmE3MWFiMiIsImZpZWxkX3R5cGUiOiJCU09OOjpPYmplY3RJZCIsImZpZWxkX25hbWUiOiJpZCIsImRpcmVjdGlvbiI6MSwiaW5jbHVkZV9jdXJyZW50IjpmYWxzZSwidGllYnJlYWtfaWQiOiI2NDA2NDU4NDA5NDQzNDI4MWZhNzFhYjIiLCJ0eXBlIjoibmV4dCJ9'
+      end
       let(:a_value) { BSON::ObjectId('64064584094434281fa71ab2') }
       let(:tiebreak_id) { a_value }
       let(:criteria) do
@@ -46,16 +60,20 @@ describe Mongoid::Scroll::Base64EncodedCursor do
           ]
         }
       end
+
+      its(:value) { is_expected.to eq a_value }
+      its(:tiebreak_id) { is_expected.to eq tiebreak_id }
+      its(:criteria) { is_expected.to eq(criteria) }
+      its(:type) { is_expected.to eq(:next) }
+      its(:to_s) { is_expected.to eq(base64_string) }
+    end
+
+    context 'an integer field cursor' do
       subject do
         Mongoid::Scroll::Base64EncodedCursor.new base64_string
       end
-      its(:value) { should eq a_value }
-      its(:tiebreak_id) { should eq tiebreak_id }
-      its(:criteria) { should eq(criteria) }
-      its(:to_s) { should eq(base64_string) }
-    end
-    context 'an integer field cursor' do
-      let(:base64_string) { 'eyJ2YWx1ZSI6MTAsImZpZWxkX3R5cGUiOiJJbnRlZ2VyIiwiZmllbGRfbmFtZSI6ImFfaW50ZWdlciIsImRpcmVjdGlvbiI6MSwiaW5jbHVkZV9jdXJyZW50IjpmYWxzZSwidGllYnJlYWtfaWQiOiI2NDA2M2RmODA5NDQzNDE3YzdkMmIxMDgifQ==' }
+
+      let(:base64_string) { 'eyJ2YWx1ZSI6MTAsImZpZWxkX3R5cGUiOiJJbnRlZ2VyIiwiZmllbGRfbmFtZSI6ImFfaW50ZWdlciIsImRpcmVjdGlvbiI6MSwiaW5jbHVkZV9jdXJyZW50IjpmYWxzZSwidGllYnJlYWtfaWQiOiI2NDA2M2RmODA5NDQzNDE3YzdkMmIxMDgiLCJ0eXBlIjoibmV4dCJ9' }
       let(:a_value) { 10 }
       let(:tiebreak_id) { BSON::ObjectId('64063df809443417c7d2b108') }
       let(:criteria) do
@@ -66,18 +84,22 @@ describe Mongoid::Scroll::Base64EncodedCursor do
           ]
         }
       end
-      subject do
-        Mongoid::Scroll::Base64EncodedCursor.new base64_string
-      end
-      its(:value) { should eq a_value }
+
+      its(:value) { is_expected.to eq a_value }
       its(:tiebreak_id) { tiebreak_id }
-      its(:value) { should eq a_value }
-      its(:tiebreak_id) { should eq tiebreak_id }
-      its(:criteria) { should eq(criteria) }
-      its(:to_s) { should eq(base64_string) }
+      its(:value) { is_expected.to eq a_value }
+      its(:tiebreak_id) { is_expected.to eq tiebreak_id }
+      its(:criteria) { is_expected.to eq(criteria) }
+      its(:type) { is_expected.to eq(:next) }
+      its(:to_s) { is_expected.to eq(base64_string) }
     end
+
     context 'a date/time field cursor' do
-      let(:base64_string) { 'eyJ2YWx1ZSI6MTM4NzU5MDEyMy4wLCJmaWVsZF90eXBlIjoiRGF0ZVRpbWUiLCJmaWVsZF9uYW1lIjoiYV9kYXRldGltZSIsImRpcmVjdGlvbiI6MSwiaW5jbHVkZV9jdXJyZW50IjpmYWxzZSwidGllYnJlYWtfaWQiOiI2NDA2NDNhNzA5NDQzNDIzOWYyZGJmODYifQ==' }
+      subject do
+        Mongoid::Scroll::Base64EncodedCursor.new base64_string
+      end
+
+      let(:base64_string) { 'eyJ2YWx1ZSI6MTM4NzU5MDEyMy4wLCJmaWVsZF90eXBlIjoiRGF0ZVRpbWUiLCJmaWVsZF9uYW1lIjoiYV9kYXRldGltZSIsImRpcmVjdGlvbiI6MSwiaW5jbHVkZV9jdXJyZW50IjpmYWxzZSwidGllYnJlYWtfaWQiOiI2NDA2NDNhNzA5NDQzNDIzOWYyZGJmODYiLCJ0eXBlIjoibmV4dCJ9' }
       let(:a_value) { DateTime.new(2013, 12, 21, 1, 42, 3, 'UTC') }
       let(:tiebreak_id) { BSON::ObjectId('640643a7094434239f2dbf86') }
       let(:criteria) do
@@ -88,16 +110,20 @@ describe Mongoid::Scroll::Base64EncodedCursor do
           ]
         }
       end
+
+      its(:value) { is_expected.to eq a_value }
+      its(:tiebreak_id) { is_expected.to eq tiebreak_id }
+      its(:criteria) { is_expected.to eq(criteria) }
+      its(:type) { is_expected.to eq(:next) }
+      its(:to_s) { is_expected.to eq(base64_string) }
+    end
+
+    context 'a date field cursor' do
       subject do
         Mongoid::Scroll::Base64EncodedCursor.new base64_string
       end
-      its(:value) { should eq a_value }
-      its(:tiebreak_id) { should eq tiebreak_id }
-      its(:criteria) { should eq(criteria) }
-      its(:to_s) { should eq(base64_string) }
-    end
-    context 'a date field cursor' do
-      let(:base64_string) { 'eyJ2YWx1ZSI6MTM4NzU4NDAwMCwiZmllbGRfdHlwZSI6IkRhdGUiLCJmaWVsZF9uYW1lIjoiYV9kYXRlIiwiZGlyZWN0aW9uIjoxLCJpbmNsdWRlX2N1cnJlbnQiOmZhbHNlLCJ0aWVicmVha19pZCI6IjY0MDY0MmM5MDk0NDM0MjEyYzRkNDQyMCJ9' }
+
+      let(:base64_string) { 'eyJ2YWx1ZSI6MTM4NzU4NDAwMCwiZmllbGRfdHlwZSI6IkRhdGUiLCJmaWVsZF9uYW1lIjoiYV9kYXRlIiwiZGlyZWN0aW9uIjoxLCJpbmNsdWRlX2N1cnJlbnQiOmZhbHNlLCJ0aWVicmVha19pZCI6IjY0MDY0MmM5MDk0NDM0MjEyYzRkNDQyMCIsInR5cGUiOiJuZXh0In0=' }
       let(:tiebreak_id) { BSON::ObjectId('640642c9094434212c4d4420') }
       let(:a_value) { Date.new(2013, 12, 21) }
       let(:criteria) do
@@ -108,16 +134,20 @@ describe Mongoid::Scroll::Base64EncodedCursor do
           ]
         }
       end
+
+      its(:value) { is_expected.to eq a_value }
+      its(:tiebreak_id) { is_expected.to eq tiebreak_id }
+      its(:criteria) { is_expected.to eq(criteria) }
+      its(:type) { is_expected.to eq(:next) }
+      its(:to_s) { is_expected.to eq(base64_string) }
+    end
+
+    context 'a time field cursor' do
       subject do
         Mongoid::Scroll::Base64EncodedCursor.new base64_string
       end
-      its(:value) { should eq a_value }
-      its(:tiebreak_id) { should eq tiebreak_id }
-      its(:criteria) { should eq(criteria) }
-      its(:to_s) { should eq(base64_string) }
-    end
-    context 'a time field cursor' do
-      let(:base64_string) { 'eyJ2YWx1ZSI6MTM4NzYwNTcyMy4wLCJmaWVsZF90eXBlIjoiVGltZSIsImZpZWxkX25hbWUiOiJhX3RpbWUiLCJkaXJlY3Rpb24iOjEsImluY2x1ZGVfY3VycmVudCI6ZmFsc2UsInRpZWJyZWFrX2lkIjoiNjQwNjNkNGEwOTQ0MzQxNjZiZDA1M2VkIn0=' }
+
+      let(:base64_string) { 'eyJ2YWx1ZSI6MTM4NzYwNTcyMy4wLCJmaWVsZF90eXBlIjoiVGltZSIsImZpZWxkX25hbWUiOiJhX3RpbWUiLCJkaXJlY3Rpb24iOjEsImluY2x1ZGVfY3VycmVudCI6ZmFsc2UsInRpZWJyZWFrX2lkIjoiNjQwNjNkNGEwOTQ0MzQxNjZiZDA1M2VkIiwidHlwZSI6Im5leHQifQ==' }
       let(:item_id) { BSON::ObjectId('640636f209443407333b46d4') }
       let(:a_value) { Time.new(2013, 12, 21, 6, 2, 3, '+00:00').utc }
       let(:tiebreak_id) { BSON::ObjectId('64063d4a094434166bd053ed') }
@@ -129,15 +159,15 @@ describe Mongoid::Scroll::Base64EncodedCursor do
           ]
         }
       end
-      subject do
-        Mongoid::Scroll::Base64EncodedCursor.new base64_string
-      end
-      its(:value) { should eq a_value }
+
+      its(:value) { is_expected.to eq a_value }
       its(:tiebreak_id) { tiebreak_id }
-      its(:tiebreak_id) { should eq tiebreak_id }
-      its(:criteria) { should eq(criteria) }
-      its(:to_s) { should eq(base64_string) }
+      its(:tiebreak_id) { is_expected.to eq tiebreak_id }
+      its(:criteria) { is_expected.to eq(criteria) }
+      its(:type) { is_expected.to eq(:next) }
+      its(:to_s) { is_expected.to eq(base64_string) }
     end
+
     context 'an invalid field cursor' do
       it 'raises ArgumentError' do
         expect do
@@ -145,6 +175,7 @@ describe Mongoid::Scroll::Base64EncodedCursor do
         end.to raise_error Mongoid::Scroll::Errors::InvalidBase64CursorError
       end
     end
+
     context 'an invalid cursor' do
       it 'raises a Mongoid::Scroll::Errors::InvalidBase64CursorError with an invalid Base64 string' do
         expect { Mongoid::Scroll::Base64EncodedCursor.new 'invalid' }.to raise_error Mongoid::Scroll::Errors::InvalidBase64CursorError, /The cursor supplied is invalid: invalid./
@@ -155,79 +186,119 @@ describe Mongoid::Scroll::Base64EncodedCursor do
       end
     end
   end
+
   context 'from_record' do
     context 'a string field cursor' do
+      subject do
+        Mongoid::Scroll::Base64EncodedCursor.from_record feed_item, field_name: field_name, field_type: field_type
+      end
+
       let(:field_type) { String }
       let(:field_value) { 'a string' }
       let(:field_name) { 'a_string' }
       let(:feed_item) { Feed::Item.create!(field_name => field_value) }
+
+      its(:value) { is_expected.to eq field_value }
+      its(:field_name) { is_expected.to eq field_name }
+      its(:field_type) { is_expected.to eq field_type.to_s }
+    end
+
+    context 'an id field cursor' do
       subject do
         Mongoid::Scroll::Base64EncodedCursor.from_record feed_item, field_name: field_name, field_type: field_type
       end
-      its(:value) { should eq field_value }
-      its(:field_name) { should eq field_name }
-      its(:field_type) { should eq field_type.to_s }
-    end
-    context 'an id field cursor' do
+
       let(:field_type) { BSON::ObjectId }
       let(:field_name) { 'id' }
       let(:feed_item) { Feed::Item.create! }
+
+      its(:value) { is_expected.to eq feed_item._id }
+      its(:field_type) { is_expected.to eq field_type.to_s }
+    end
+
+    context 'an integer field cursor' do
       subject do
         Mongoid::Scroll::Base64EncodedCursor.from_record feed_item, field_name: field_name, field_type: field_type
       end
-      its(:value) { should eq feed_item._id }
-      its(:field_type) { should eq field_type.to_s }
-    end
-    context 'an integer field cursor' do
+
       let(:field_type) { Integer }
       let(:field_value) { 10 }
       let(:field_name) { 'a_integer' }
       let(:feed_item) { Feed::Item.create!(field_name => field_value) }
+
+      its(:value) { is_expected.to eq field_value }
+      its(:field_type) { is_expected.to eq field_type.to_s }
+    end
+
+    context 'a date/time field cursor' do
       subject do
         Mongoid::Scroll::Base64EncodedCursor.from_record feed_item, field_name: field_name, field_type: field_type
       end
-      its(:value) { should eq field_value }
-      its(:field_type) { should eq field_type.to_s }
-    end
-    context 'a date/time field cursor' do
+
       let(:field_type) { DateTime }
       let(:field_value) { DateTime.new(2013, 12, 21, 1, 42, 3, 'UTC') }
       let(:field_name) { 'a_datetime' }
       let(:feed_item) { Feed::Item.create!(field_name => field_value) }
+
+      its(:value) { is_expected.to eq field_value }
+      its(:field_type) { is_expected.to eq field_type.to_s }
+    end
+
+    context 'a date field cursor' do
       subject do
         Mongoid::Scroll::Base64EncodedCursor.from_record feed_item, field_name: field_name, field_type: field_type
       end
-      its(:value) { should eq field_value }
-      its(:field_type) { should eq field_type.to_s }
-    end
-    context 'a date field cursor' do
+
       let(:field_type) { Date }
       let(:field_value) { Date.new(2013, 12, 21) }
       let(:field_name) { 'a_date' }
       let(:feed_item) { Feed::Item.create!(field_name => field_value) }
+
+      its(:value) { is_expected.to eq field_value }
+    end
+
+    context 'a time field cursor' do
       subject do
         Mongoid::Scroll::Base64EncodedCursor.from_record feed_item, field_name: field_name, field_type: field_type
       end
-      its(:value) { should eq field_value }
-    end
-    context 'a time field cursor' do
+
       let(:field_type) { Time }
       let(:field_value) { Time.new(2013, 12, 21, 1, 2, 3) }
       let(:field_name) { 'a_time' }
       let(:feed_item) { Feed::Item.create!(field_name => field_value) }
-      subject do
-        Mongoid::Scroll::Base64EncodedCursor.from_record feed_item, field_name: field_name, field_type: field_type
-      end
-      its(:value) { should eq field_value }
-      its(:field_type) { should eq field_type.to_s }
+
+      its(:value) { is_expected.to eq field_value }
+      its(:field_type) { is_expected.to eq field_type.to_s }
     end
+
     context 'an array field cursor' do
       let(:feed_item) { Feed::Item.create!(a_array: %w[x y]) }
+
       it 'is not supported' do
         expect do
           Mongoid::Scroll::Base64EncodedCursor.from_record feed_item, field_name: 'a_array', field_type: Array
         end.to raise_error Mongoid::Scroll::Errors::UnsupportedFieldTypeError, /The type of the field 'a_array' is not supported: Array./
       end
     end
+
+    it 'encode and decode type option' do
+      feed_item = Feed::Item.create!
+      cursor = Mongoid::Scroll::Base64EncodedCursor.from_record feed_item, field_name: 'id', field_type: BSON::ObjectId, type: :previous
+      expect(Mongoid::Scroll::Base64EncodedCursor.new(cursor.to_s).type).to eq(:previous)
+    end
+
+    context 'a cursor with previous set to true' do
+      subject do
+        Mongoid::Scroll::Base64EncodedCursor.from_record feed_item, field_name: field_name, field_type: field_type, type: :previous
+      end
+
+      let(:field_type) { BSON::ObjectId }
+      let(:field_name) { 'id' }
+      let(:feed_item) { Feed::Item.create! }
+
+      its(:value) { is_expected.to eq feed_item._id }
+      its(:field_type) { is_expected.to eq field_type.to_s }
+      its(:type) { is_expected.to eq(:previous) }
+    end
   end
 end