mongoid-scroll 0.1.0

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format=documentation
+

data/.travis.yml

@@ -0,0 +1,5 @@
+services:
+  - mongodb
+
+rvm:
+  - 1.9.3

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+0.1.0 (TBD)
+===========
+
+* Initial public release - [@dblock](https://github.com/dblock).
+

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://rubygems.org"
+
+gemspec
+
+group :development, :test do
+  gem "rake"
+  gem "bundler"
+  gem "rspec"
+end

data/LICENSE.md

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2012 Daniel Doubrovkine, Artsy Inc.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,87 @@
+Mongoid::Scroll [![Build Status](https://travis-ci.org/dblock/mongoid-scroll.png?branch=master)](https://travis-ci.org/dblock/mongoid-scroll)
+===============
+
+Mongoid extension that enable infinite scrolling.
+
+The Problem
+-----------
+
+Traditional pagination does not work when data changes between paginated requests, which makes it unsuitable for infinite scroll behaviors.
+
+* If a record is inserted before the current page limit, the collection will shift to the right, and the returned result will include a duplicate from a previous page.
+* If a record is removed before the current page limit, the collection will shift to the left, and the returned result will be missing a record.
+
+The solution implemented by the `scroll` extension paginates data using a cursor, giving you the ability to restart pagination where you left it off. This is a non-trivial problem when combined with sorting over non-unique record fields, such as timestamps.
+
+Usage
+-----
+
+Add `mongoid-scroll` to Gemfile.
+
+```ruby
+gem 'mongoid-scroll'
+```
+
+A sample model.
+
+```ruby
+module Feed
+  class Item
+    include Mongoid::Document
+    field :content, type: String
+    field :created_at, type: DateTime
+  end
+end
+```
+
+Scroll and save a cursor to the last item.
+
+```ruby
+saved_cursor = nil
+Feed::Item.desc(:created_at).limit(5).scroll do |record, next_cursor|
+  # each record, one-by-one
+  saved_cursor = next_cursor
+end
+```
+
+Resume iterating using the previously saved cursor.
+
+```ruby
+Feed::Item.desc(:created_at).limit(5).scroll(saved_cursor) do |record, next_cursor|
+  # each record, one-by-one
+  saved_cursor = next_cursor
+end
+```
+
+The iteration finishes when no more records are available. You can also finish iterating over the remaining records by omitting the query limit.
+
+```ruby
+Feed::Item.desc(:created_at).scroll(saved_cursor) do |record, next_cursor|
+  # each record, one-by-one
+end
+```
+
+Cursors
+-------
+
+You can use `Mongoid::Scroll::Cursor.from_record` to generate a cursor. This can be useful when you just want to return a collection of results and the cursor pointing to after the last item.
+
+```ruby
+record = Feed::Item.desc(:created_at).limit(3).last
+cursor = Mongoid::Scroll::Cursor.from_record(record, { field: Feed::Item.fields["created_at"] })
+# cursor or cursor.to_s can be returned to a client and passed into .scroll(cursor)
+```
+
+Note that unlike MongoDB cursors, `Mongoid::Scroll::Cursor` values don't expire.
+
+Contributing
+------------
+
+Fork the project. Make your feature addition or bug fix with tests. Send a pull request. Bonus points for topic branches.
+
+Copyright and License
+---------------------
+
+MIT License, see [LICENSE](http://github.com/dblock/mongoid-scroll/raw/master/LICENSE.md) for details.
+
+(c) 2013 [Daniel Doubrovkine](http://github.com/dblock), based on code by [Frank Macreery](http://github.com/macreery), [Artsy Inc.](http://artsy.net)

data/Rakefile

@@ -0,0 +1,24 @@
+require 'rubygems'
+require 'bundler/gem_tasks'
+
+require File.expand_path('../lib/mongoid/scroll/version', __FILE__)
+
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rake'
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+task :default => :spec
+

data/lib/config/locales/en.yml

@@ -0,0 +1,22 @@
+en:
+  mongoid:
+    scroll:
+      errors:
+        messages:
+          multiple_sort_fields:
+            message: "Scrolling over a criteria with multiple fields is not supported."
+            summary: "You're attempting to scroll over data with a sort order that includes multiple fields: %{sort}."
+            resolution: "Simplify the sort order to a single field."
+          invalid_cursor:
+            message: "The cursor supplied is invalid."
+            summary: "The cursor supplied is invalid: %{cursor}."
+            resolution: "Cursors must be in the form 'value:tiebreak_id'."
+          no_such_field:
+            message: "Invalid field."
+            summary: "The field supplied in the cursor does not exist: %{field}."
+            resolution: "Has the model changed or are you not sorting the criteria by the right field."
+          unsupported_field_type:
+            message: "Unsupported field type."
+            summary: "The type of the field '%{field}' is not supported: %{type}."
+            resolution: "Please open a feature request in https://github.com/dblock/mongoid-scroll."
+

data/lib/mongoid/criterion/scrollable.rb

@@ -0,0 +1,33 @@
+module Mongoid
+  module Criterion
+    module Scrollable
+
+      def scroll(cursor = nil, &block)
+        c = self
+        # we don't support scrolling over a criteria with multiple fields
+        if c.options[:sort] && c.options[:sort].keys.count != 1
+          sort = c.options[:sort].keys.join(", ")
+          raise Mongoid::Scroll::Errors::MultipleSortFieldsError.new(sort: sort)
+        end
+        # introduce a default sort order if there's none
+        c = c.asc(:_id) if (! c.options[:sort]) || c.options[:sort].empty?
+        # scroll field and direction
+        scroll_field = c.options[:sort].keys.first
+        scroll_direction = c.options[:sort].values.first.to_i == 1 ? '$gt' : '$lt'
+        # scroll cursor from the parameter, with value and tiebreak_id
+        field = c.klass.fields[scroll_field.to_s]
+        cursor_options = { field: field, direction: scroll_direction }
+        cursor = cursor.is_a?(Mongoid::Scroll::Cursor) ? cursor : Mongoid::Scroll::Cursor.new(cursor, cursor_options)
+        # scroll
+        if block_given?
+          c.where(cursor.criteria).each do |record|
+            yield record, Mongoid::Scroll::Cursor.from_record(record, cursor_options)
+          end
+        else
+          c
+        end
+      end
+
+    end
+  end
+end

data/lib/mongoid/scroll/cursor.rb

@@ -0,0 +1,78 @@
+module Mongoid
+  module Scroll
+    class Cursor
+
+      attr_accessor :value, :tiebreak_id, :field, :direction
+
+      def initialize(value = nil, options = {})
+        unless options && (@field = options[:field])
+          raise ArgumentError.new "Missing options[:field]."
+        end
+        @direction = options[:direction] || '$gt'
+        @value, @tiebreak_id = Mongoid::Scroll::Cursor.parse(value, options)
+      end
+
+      def criteria
+        cursor_criteria = { field.name => { direction => value } } if value
+        tiebreak_criteria = { field.name => value, :_id => { '$gt' => tiebreak_id } } if value && tiebreak_id
+        (cursor_criteria || tiebreak_criteria) ? { '$or' => [ cursor_criteria, tiebreak_criteria].compact } : {}
+      end
+
+      class << self
+        def from_record(record, options)
+          unless options && (field = options[:field])
+            raise ArgumentError.new "Missing options[:field]."
+          end
+          Mongoid::Scroll::Cursor.new("#{transform_field_value(field, record.send(field.name))}:#{record.id}", options)
+        end
+      end
+
+      def to_s
+        tiebreak_id ? [ Mongoid::Scroll::Cursor.transform_field_value(field, value), tiebreak_id ].join(":") : nil
+      end
+
+      private
+
+        class << self
+
+          def parse(value, options)
+            return [ nil, nil ] unless value
+            parts = value.split(":")
+            unless parts.length >= 2
+              raise Mongoid::Scroll::Errors::InvalidCursorError.new({ cursor: value })
+            end
+            id = parts[-1]
+            value = parts[0...-1].join(":")
+            [ parse_field_value(options[:field], value), Moped::BSON::ObjectId(id) ]
+          end
+
+          def parse_field_value(field, value)
+            case field.type.to_s
+            when "String" then value.to_s
+            when "DateTime" then Time.at(value.to_i).to_datetime
+            when "Time" then Time.at(value.to_i)
+            when "Date" then Time.at(value.to_i).utc.to_date
+            when "Float" then value.to_f
+            when "Integer" then value.to_i
+            else
+              raise Mongoid::Scroll::Errors::UnsupportedFieldTypeError.new(field: field.name, type: field.type)
+            end
+          end
+
+          def transform_field_value(field, value)
+            case field.type.to_s
+            when "String" then value.to_s
+            when "Date" then value.to_time(:utc).to_i
+            when "DateTime", "Time" then value.to_i
+            when "Float" then value.to_f
+            when "Integer" then value.to_i
+            else
+              raise Mongoid::Scroll::Errors::UnsupportedFieldTypeError.new(field: field.name, type: field.type)
+            end
+          end
+
+        end
+
+    end
+  end
+end

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

@@ -0,0 +1,81 @@
+module Mongoid
+  module Scroll
+    module Errors
+      class Base < StandardError
+
+        # Problem occurred.
+        attr_reader :problem
+
+        # Summary of the problem.
+        attr_reader :summary
+
+        # Suggested problem resolution.
+        attr_reader :resolution
+
+        # Compose the message.
+        # === Parameters
+        # [key] Lookup key in the translation table.
+        # [attributes] The objects to pass to create the message.
+        def compose_message(key, attributes = {})
+          @problem = create_problem(key, attributes)
+          @summary = create_summary(key, attributes)
+          @resolution = create_resolution(key, attributes)
+
+          "\nProblem:\n  #{@problem}"+
+          "\nSummary:\n  #{@summary}"+
+          "\nResolution:\n  #{@resolution}"
+        end
+
+        private
+
+          BASE_KEY = "mongoid.scroll.errors.messages" #:nodoc:
+
+          # Given the key of the specific error and the options hash, translate the
+          # message.
+          #
+          # === Parameters
+          # [key] The key of the error in the locales.
+          # [options] The objects to pass to create the message.
+          #
+          # Returns a localized error message string.
+          def translate(key, options)
+            ::I18n.translate("#{BASE_KEY}.#{key}", { :locale => :en }.merge(options)).strip
+          end
+
+          # Create the problem.
+          #
+          # === Parameters
+          # [key] The error key.
+          # [attributes] The attributes to interpolate.
+          #
+          # Returns the problem.
+          def create_problem(key, attributes)
+            translate("#{key}.message", attributes)
+          end
+
+          # Create the summary.
+          #
+          # === Parameters
+          # [key] The error key.
+          # [attributes] The attributes to interpolate.
+          #
+          # Returns the summary.
+          def create_summary(key, attributes)
+            translate("#{key}.summary", attributes)
+          end
+
+          # Create the resolution.
+          #
+          # === Parameters
+          # [key] The error key.
+          # [attributes] The attributes to interpolate.
+          #
+          # Returns the resolution.
+          def create_resolution(key, attributes)
+            translate("#{key}.resolution", attributes)
+          end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Mongoid
+  module Scroll
+    module Errors
+      class InvalidCursorError < Mongoid::Scroll::Errors::Base
+
+        def initialize(opts = {})
+          super(compose_message("invalid_cursor", opts))
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Mongoid
+  module Scroll
+    module Errors
+      class MultipleSortFieldsError < Mongoid::Scroll::Errors::Base
+
+        def initialize(opts = {})
+          super(compose_message("multiple_sort_fields", opts))
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Mongoid
+  module Scroll
+    module Errors
+      class NoSuchFieldError < Mongoid::Scroll::Errors::Base
+
+        def initialize(opts = {})
+          super(compose_message("no_such_field", opts))
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+module Mongoid
+  module Scroll
+    module Errors
+      class UnsupportedFieldTypeError < Mongoid::Scroll::Errors::Base
+
+        def initialize(opts = {})
+          super(compose_message("unsupported_field_type", opts))
+        end
+
+      end
+    end
+  end
+end

data/lib/mongoid/scroll/errors.rb

@@ -0,0 +1,5 @@
+require 'mongoid/scroll/errors/base'
+require 'mongoid/scroll/errors/multiple_sort_fields_error'
+require 'mongoid/scroll/errors/invalid_cursor_error'
+require 'mongoid/scroll/errors/no_such_field_error'
+require 'mongoid/scroll/errors/unsupported_field_type_error'

data/lib/mongoid/scroll/version.rb

@@ -0,0 +1,5 @@
+module Mongoid
+  module Scroll
+    VERSION = '0.1.0'
+  end
+end

data/lib/mongoid-scroll.rb

@@ -0,0 +1,11 @@
+require 'i18n'
+
+I18n.load_path << File.join(File.dirname(__FILE__), "config", "locales", "en.yml")
+
+require 'mongoid'
+require 'mongoid/scroll/version'
+require 'mongoid/scroll/errors'
+require 'mongoid/scroll/cursor'
+require 'mongoid/criterion/scrollable'
+
+Mongoid::Criteria.send(:include, Mongoid::Criterion::Scrollable)

data/lib/mongoid_scroll.rb

@@ -0,0 +1,2 @@
+require 'mongoid-scroll'
+

data/mongoid-scroll.gemspec

@@ -0,0 +1,20 @@
+$:.push File.expand_path("../lib", __FILE__)
+require "mongoid/scroll/version"
+
+Gem::Specification.new do |s|
+  s.name = "mongoid-scroll"
+  s.version = Mongoid::Scroll::VERSION
+  s.authors = [ "Daniel Doubrovkine", "Frank Macreery" ]
+  s.email = "dblock@dblock.org"
+  s.platform = Gem::Platform::RUBY
+  s.required_rubygems_version = '>= 1.3.6'
+  s.files = `git ls-files`.split("\n")
+  s.require_paths = [ "lib" ]
+  s.homepage = "http://github.com/dblock/mongoid-scroll"
+  s.licenses = [ "MIT" ]
+  s.summary = "Mongoid extensions to enable infinite scroll."
+  s.add_dependency "mongoid", ">= 3.0"
+  s.add_dependency "i18n"
+end
+
+

data/spec/mongoid/criteria_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+describe Mongoid::Criteria do
+  context "scrollable" do
+    subject do
+      Feed::Item
+    end
+    it ":scroll" do
+      subject.should.respond_to? :scroll
+    end
+  end
+  context "with multiple sort fields" do
+    subject do
+      Feed::Item.desc(:name).asc(:value)
+    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
+      Feed::Item.all
+    end
+    it "adds a default sort by _id" do
+      subject.scroll.options[:sort].should == { "_id" => 1 }
+    end
+  end
+  context "with data" do
+    before :each do
+      10.times do |i|
+        Feed::Item.create!(
+          a_string: i.to_s,
+          a_integer: i,
+          a_datetime: DateTime.new(2013, i + 1, 21, 1, 42, 3)
+        )
+      end
+    end
+    context "integer" do
+      it "scrolls all with a block" do
+        records = []
+        Feed::Item.asc(:a_integer).scroll do |record, next_cursor|
+          records << record
+        end
+        records.size.should == 10
+        records.should eq Feed::Item.all.to_a
+      end
+      it "scrolls all with a break" do
+        records = []
+        cursor = nil
+        Feed::Item.asc(:a_integer).limit(5).scroll do |record, next_cursor|
+          records << record
+          cursor = next_cursor
+        end
+        records.size.should == 5
+        Feed::Item.asc(:a_integer).scroll(cursor) do |record, next_cursor|
+          records << record
+          cursor = next_cursor
+        end
+        records.size.should == 10
+        records.should eq Feed::Item.all.to_a
+      end
+      it "scrolls in descending order" do
+        records = []
+        Feed::Item.desc(:a_integer).limit(3).scroll do |record, next_cursor|
+          records << record
+        end
+        records.size.should == 3
+        records.should eq Feed::Item.desc(:a_integer).limit(3).to_a
+      end
+      it "map" do
+        record = Feed::Item.desc(:a_integer).limit(3).scroll.map { |record, cursor| record }.last
+        cursor = Mongoid::Scroll::Cursor.from_record(record, { field: Feed::Item.fields["a_integer"] })
+        cursor.should_not be_nil
+        cursor.to_s.split(":").should == [ record.a_integer.to_s, record.id.to_s ]
+      end
+    end
+  end
+  context "with overlapping data" do
+    before :each do
+      3.times { Feed::Item.create! a_integer: 5 }
+    end
+    it "scrolls" do
+      records = []
+      cursor = nil
+      Feed::Item.desc(:a_integer).limit(2).scroll do |record, next_cursor|
+        records << record
+        cursor = next_cursor
+      end
+      records.size.should == 2
+      Feed::Item.desc(:a_integer).scroll(cursor) do |record, next_cursor|
+        records << record
+      end
+      records.size.should == 3
+      records.should eq Feed::Item.all.to_a
+    end
+  end
+end

data/spec/mongoid/scroll_cursor_spec.rb

@@ -0,0 +1,106 @@
+require 'spec_helper'
+
+describe Mongoid::Scroll::Cursor do
+  context "an empty cursor" do
+    subject do
+      Mongoid::Scroll::Cursor.new(nil, { field: Feed::Item.fields["a_string"]})
+    end
+    its(:tiebreak_id) { should be_nil }
+    its(:value) { should be_nil }
+    its(:criteria) { should eq({}) }
+  end
+  context "an invalid cursor" do
+    it "raises InvalidCursorError" do
+      expect { Mongoid::Scroll::Cursor.new "invalid", field: Feed::Item.fields["a_string"] }.to raise_error Mongoid::Scroll::Errors::InvalidCursorError,
+        /The cursor supplied is invalid: invalid./
+    end
+  end
+  context "a string field cursor" do
+    let(:feed_item) { Feed::Item.create!(a_string: "astring") }
+    subject do
+      Mongoid::Scroll::Cursor.new "#{feed_item.a_string}:#{feed_item.id}", field: Feed::Item.fields["a_string"]
+    end
+    its(:value) { should eq feed_item.a_string }
+    its(:tiebreak_id) { should eq feed_item.id }
+    its(:criteria) {
+      should eq({ "$or" => [
+        { "a_string" => { "$gt" => feed_item.a_string }},
+        { "a_string" => feed_item.a_string, :_id => { "$gt" => feed_item.id }}
+      ]})
+    }
+  end
+  context "an integer field cursor" do
+    let(:feed_item) { Feed::Item.create!(a_integer: 10) }
+    subject do
+      Mongoid::Scroll::Cursor.new "#{feed_item.a_integer}:#{feed_item.id}", field: Feed::Item.fields["a_integer"]
+    end
+    its(:value) { should eq feed_item.a_integer }
+    its(:tiebreak_id) { should eq feed_item.id }
+    its(:criteria) {
+      should eq({ "$or" => [
+        { "a_integer" => { "$gt" => feed_item.a_integer }},
+        { "a_integer" => feed_item.a_integer, :_id => { "$gt" => feed_item.id }}
+      ]})
+    }
+  end
+  context "a date/time field cursor" do
+    let(:feed_item) { Feed::Item.create!(a_datetime: DateTime.new(2013, 12, 21, 1, 42, 3)) }
+    subject do
+      Mongoid::Scroll::Cursor.new "#{feed_item.a_datetime.to_i}:#{feed_item.id}", field: Feed::Item.fields["a_datetime"]
+    end
+    its(:value) { should eq feed_item.a_datetime }
+    its(:tiebreak_id) { should eq feed_item.id }
+    its(:to_s) { should eq "#{feed_item.a_datetime.to_i}:#{feed_item.id}" }
+    its(:criteria) {
+      should eq({ "$or" => [
+        { "a_datetime" => { "$gt" => feed_item.a_datetime }},
+        { "a_datetime" => feed_item.a_datetime, :_id => { "$gt" => feed_item.id }}
+      ]})
+    }
+  end
+  context "a date field cursor" do
+    let(:feed_item) { Feed::Item.create!(a_date: Date.new(2013, 12, 21)) }
+    subject do
+      Mongoid::Scroll::Cursor.new "#{feed_item.a_date.to_datetime.to_i}:#{feed_item.id}", field: Feed::Item.fields["a_date"]
+    end
+    its(:value) { should eq feed_item.a_date }
+    its(:tiebreak_id) { should eq feed_item.id }
+    its(:to_s) { should eq "#{feed_item.a_date.to_datetime.to_i}:#{feed_item.id}" }
+    its(:criteria) {
+      should eq({ "$or" => [
+        { "a_date" => { "$gt" => feed_item.a_date.to_datetime }},
+        { "a_date" => feed_item.a_date.to_datetime, :_id => { "$gt" => feed_item.id }}
+      ]})
+    }
+  end
+  context "a time field cursor" do
+    let(:feed_item) { Feed::Item.create!(a_time: Time.new(2013, 12, 21, 1, 2, 3)) }
+    subject do
+      Mongoid::Scroll::Cursor.new "#{feed_item.a_time.to_i}:#{feed_item.id}", field: Feed::Item.fields["a_time"]
+    end
+    its(:value) { should eq feed_item.a_time }
+    its(:tiebreak_id) { should eq feed_item.id }
+    its(:to_s) { should eq "#{feed_item.a_time.to_i}:#{feed_item.id}" }
+    its(:criteria) {
+      should eq({ "$or" => [
+        { "a_time" => { "$gt" => feed_item.a_time }},
+        { "a_time" => feed_item.a_time, :_id => { "$gt" => feed_item.id }}
+      ]})
+    }
+  end
+  context "an array field cursor" do
+    let(:feed_item) { Feed::Item.create!(a_array: [ "x", "y" ]) }
+    it "is not supported" do
+      expect {
+        Mongoid::Scroll::Cursor.from_record(feed_item, field: Feed::Item.fields["a_array"])
+      }.to raise_error Mongoid::Scroll::Errors::UnsupportedFieldTypeError, /The type of the field 'a_array' is not supported: Array./
+    end
+  end
+  context "an invalid field cursor" do
+    it "raises ArgumentError" do
+      expect {
+        Mongoid::Scroll::Cursor.new "invalid:whatever", {}
+      }.to raise_error ArgumentError
+    end
+  end
+end

data/spec/mongoid/scroll_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe Mongoid::Scroll::VERSION do
+  it { should_not be_nil }
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+require 'rubygems'
+require 'rspec'
+require 'mongoid-scroll'
+
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each do |f|
+  require f
+end
+
+Mongoid.configure do |config|
+  config.connect_to 'mongoid_scroll_test'
+end
+
+RSpec.configure do |config|
+  config.before :each do
+    Mongoid.purge!
+  end
+end
+

data/spec/support/feed/item.rb

@@ -0,0 +1,13 @@
+module Feed
+  class Item
+    include Mongoid::Document
+
+    field :a_field
+    field :a_integer, type: Integer
+    field :a_string, type: String
+    field :a_datetime, type: DateTime
+    field :a_date, type: Date
+    field :a_time, type: Time
+    field :a_array, type: Array
+  end
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: mongoid-scroll
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Daniel Doubrovkine
+- Frank Macreery
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mongoid
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: 
+email: dblock@dblock.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .travis.yml
+- CHANGELOG.md
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/config/locales/en.yml
+- lib/mongoid-scroll.rb
+- lib/mongoid/criterion/scrollable.rb
+- lib/mongoid/scroll/cursor.rb
+- lib/mongoid/scroll/errors.rb
+- lib/mongoid/scroll/errors/base.rb
+- lib/mongoid/scroll/errors/invalid_cursor_error.rb
+- 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/version.rb
+- lib/mongoid_scroll.rb
+- mongoid-scroll.gemspec
+- spec/mongoid/criteria_spec.rb
+- spec/mongoid/scroll_cursor_spec.rb
+- spec/mongoid/scroll_spec.rb
+- spec/spec_helper.rb
+- spec/support/feed/item.rb
+homepage: http://github.com/dblock/mongoid-scroll
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 1370092332583330753
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: 1.3.6
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Mongoid extensions to enable infinite scroll.
+test_files: []