mongoid-scroll 0.2.1 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 614ee5395d9475c74547769cefbfd7c531b09d45
+  data.tar.gz: 9a61c61ce360c352a4b69fd770eca27f1ee9a6c7
+SHA512:
+  metadata.gz: 05e6f26d88ad8515bb3d0871bed4ea5386d3fb801300394ffedbdb4529833b2fb19ed73da362267e35cba02fba6b11c74e4d8ca4bfecb93cb389bc2408967c84
+  data.tar.gz: 3511a0273d3c198987a5812cfb137083216373e6602d03cbfe828ad0fa8c65d4fc577c20598bb1a8239c480d4f891d2179fa89e382b942347e01a063c4bd18a1

data/.rubocop.yml

@@ -0,0 +1,64 @@
+AllCops:
+  Exclude:
+    - vendor/**/*
+    - gemfiles/vendor/**/*
+
+LineLength:
+  Enabled: false
+
+MethodLength:
+  Enabled: false
+
+ClassLength:
+  Enabled: false
+
+Documentation:
+  # don't require classes to be documented
+  Enabled: false
+
+CollectionMethods:
+  # don't prefer map to collect, recuce to inject
+  Enabled: false
+
+Encoding:
+  # no need to always specify encoding
+  Enabled: false
+
+Void:
+  # == operator used in void context in specs
+  Enabled: false
+
+SignalException:
+  # prefer raise to fail
+  EnforcedStyle: only_raise
+
+RaiseArgs:
+  # don't care for what kind of raise
+  Enabled: false
+
+PerlBackrefs:
+  # TODO: regular expression matching with $1, $2, etc.
+  Enabled: false
+
+BlockNesting:
+  # TODO: fix too much nesting
+  Max: 4
+
+Lambda:
+  # TODO: replace all lambda with -> or Proc
+  Enabled: false
+
+Blocks:
+  # allow multi-line blocks like expect { }
+  Enabled: false
+
+WordArray:
+  # %w vs. [ '', ... ]
+  Enabled: false
+
+CyclomaticComplexity:
+  Enabled: false
+
+FileName:
+  Enabled: false
+

data/.travis.yml

@@ -3,3 +3,15 @@ services:
 
 rvm:
   - 1.9.3
+  - 2.0.0
+  - 2.1.2
+  - jruby-19mode
+  - rbx-2
+
+env:
+  - MONGOID_VERSION=3
+  - MONGOID_VERSION=4
+
+language: ruby
+
+cache: bundler

data/CHANGELOG.md

@@ -1,16 +1,22 @@
+0.3.0 (1/7/2014)
+----------------
+
+* Compatibility with Mongoid 4.x - [@dblock](https://github.com/dblock).
+* Implemeneted Rubocop, Ruby linter - [@dblock](https://github.com/dblock).
+
 0.2.1 (3/21/2013)
-=================
+-----------------
 
 * Fix: scroll over a collection that has duplicate values while data is being modified in a way that causes a change in the natural sort order - [@dblock](https://github.com/dblock).
 
 0.2.0 (3/14/2013)
-=================
+-----------------
 
 * Extended `Moped::Query` with `scroll` - [@dblock](https://github.com/dblock).
 * `Mongoid::Scroll::Cursor.from_record` can now be called with either a Mongoid field or `field_type` and `field_name` in the `options` hash - [@dblock](https://github.com/dblock).
 
 0.1.0 (2/14/2013)
-=================
+-----------------
 
 * Initial public release, extends `Mongoid::Criteria` with `scroll` - [@dblock](https://github.com/dblock).
 

data/Gemfile

@@ -2,9 +2,19 @@ source "http://rubygems.org"
 
 gemspec
 
+case version = ENV['MONGOID_VERSION'] || '~> 4.0'
+when /4/
+  gem 'mongoid', '~> 4.0'
+when /3/
+  gem 'mongoid', '~> 3.1'
+else
+  gem 'mongoid', version
+end
+
 group :development, :test do
   gem "rake"
   gem "bundler"
-  gem "rspec"
+  gem "rspec", "~> 2.9"
   gem "faker"
+  gem "rubocop", "0.24.0"
 end

data/README.md

@@ -6,7 +6,7 @@ Mongoid extension that enables infinite scrolling for `Mongoid::Criteria` and `M
 Demo
 ----
 
-Check out [artsy.net](http://artsy.net) homepage. Scroll down.
+Check out [shows on artsy.net](http://artsy.net/shows). Keep scrolling down.
 
 There're also two code samples for Mongoid and Moped in [examples](examples). Run `bundle exec ruby examples/mongoid_scroll_feed.rb`.
 

data/Rakefile

@@ -7,7 +7,7 @@ begin
   Bundler.setup(:default, :development)
 rescue Bundler::BundlerError => e
   $stderr.puts e.message
-  $stderr.puts "Run `bundle install` to install missing gems"
+  $stderr.puts 'Run `bundle install` to install missing gems'
   exit e.status_code
 end
 
@@ -20,5 +20,8 @@ RSpec::Core::RakeTask.new(:spec) do |spec|
   spec.pattern = FileList['spec/**/*_spec.rb']
 end
 
-task :default => :spec
+task :spec
+require 'rubocop/rake_task'
+RuboCop::RakeTask.new(:rubocop)
 
+task default: [:rubocop, :spec]

data/examples/mongoid_scroll_feed.rb

@@ -4,7 +4,7 @@ Bundler.setup(:default, :development)
 require 'mongoid-scroll'
 require 'faker'
 
-Mongoid.connect_to "mongoid_scroll_demo"
+Mongoid.connect_to 'mongoid_scroll_demo'
 Mongoid.purge!
 
 module Feed
@@ -12,7 +12,7 @@ module Feed
     include Mongoid::Document
     field :title, type: String
     field :position, type: Integer
-    index({ position: 1, _id: 1 })
+    index(position: 1, _id: 1)
   end
 end
 
@@ -23,7 +23,7 @@ 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 |i|
+total_items.times do |_i|
   Feed::Item.create! title: Faker::Lorem.sentence, position: rands.pop
 end
 
@@ -34,7 +34,7 @@ Feed::Item.create_indexes
 
 total_shown = 0
 next_cursor = nil
-while true
+loop do
   current_cursor = next_cursor
   next_cursor = nil
   Feed::Item.asc(:position).limit(scroll_by).scroll(current_cursor) do |item, cursor|

data/examples/moped_scroll_feed.rb

@@ -4,7 +4,7 @@ Bundler.setup(:default, :development)
 require 'mongoid-scroll'
 require 'faker'
 
-Mongoid.connect_to "mongoid_scroll_demo"
+Mongoid.connect_to 'mongoid_scroll_demo'
 Mongoid.purge!
 
 # total items to insert
@@ -14,7 +14,7 @@ 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 |i|
+total_items.times do
   Mongoid.default_session['feed_items'].insert(title: Faker::Lorem.sentence, position: rands.pop)
 end
 
@@ -25,10 +25,10 @@ Moped.logger.level = Logger::DEBUG
 
 total_shown = 0
 next_cursor = nil
-while true
+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|
+  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
@@ -36,7 +36,7 @@ while true
   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
+  Mongoid.default_session['feed_items'].find(_id: item['_id']).remove
 end
 
 # this will be 20

data/lib/mongoid/criterion/scrollable.rb

@@ -1,13 +1,12 @@
 module Mongoid
   module Criterion
     module Scrollable
-
-      def scroll(cursor = nil, &block)
+      def scroll(cursor = nil, &_block)
         criteria = self
         # we don't support scrolling over a criteria with multiple fields
         if criteria.options[:sort] && criteria.options[:sort].keys.size != 1
           raise Mongoid::Scroll::Errors::MultipleSortFieldsError.new(sort: criteria.options[:sort])
-        elsif ! criteria.options.has_key?(:sort) || criteria.options[:sort].empty?
+        elsif !criteria.options.key?(:sort) || criteria.options[:sort].empty?
           # introduce a default sort order if there's none
           criteria = criteria.asc(:_id)
         end
@@ -27,7 +26,6 @@ module Mongoid
           criteria
         end
       end
-
     end
   end
 end

data/lib/mongoid/scroll/cursor.rb

@@ -1,7 +1,6 @@
 module Mongoid
   module Scroll
     class Cursor
-
       attr_accessor :value, :tiebreak_id, :field_type, :field_name, :direction
 
       def initialize(value = nil, options = {})
@@ -12,10 +11,10 @@ module Mongoid
 
       def criteria
         mongo_value = value.class.mongoize(value) if value
-        compare_direction = direction == 1 ? "$gt" : "$lt"
+        compare_direction = direction == 1 ? '$gt' : '$lt'
         cursor_criteria = { field_name => { compare_direction => mongo_value } } if mongo_value
         tiebreak_criteria = { field_name => mongo_value, :_id => { compare_direction => tiebreak_id } } if mongo_value && tiebreak_id
-        (cursor_criteria || tiebreak_criteria) ? { '$or' => [ cursor_criteria, tiebreak_criteria].compact } : {}
+        cursor_criteria || tiebreak_criteria ? { '$or' => [cursor_criteria, tiebreak_criteria].compact } : {}
       end
 
       class << self
@@ -23,70 +22,71 @@ module Mongoid
           cursor = Mongoid::Scroll::Cursor.new(nil, options)
           value = record.respond_to?(cursor.field_name) ? record.send(cursor.field_name) : record[cursor.field_name]
           cursor.value = Mongoid::Scroll::Cursor.parse_field_value(cursor.field_type, cursor.field_name, value)
-          cursor.tiebreak_id = record["_id"]
+          cursor.tiebreak_id = record['_id']
           cursor
         end
       end
 
       def to_s
-        tiebreak_id ? [ Mongoid::Scroll::Cursor.transform_field_value(field_type, field_name, value), tiebreak_id ].join(":") : nil
+        tiebreak_id ? [Mongoid::Scroll::Cursor.transform_field_value(field_type, field_name, value), tiebreak_id].join(':') : nil
       end
 
       private
 
-        def parse(value)
-          return 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(":")
-          @value = Mongoid::Scroll::Cursor.parse_field_value(field_type, field_name, value)
+      def parse(value)
+        return 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(':')
+        @value = Mongoid::Scroll::Cursor.parse_field_value(field_type, field_name, value)
+        if Mongoid::Scroll.mongoid3?
           @tiebreak_id = Moped::BSON::ObjectId(id)
+        else
+          @tiebreak_id = BSON::ObjectId.from_string(id)
         end
+      end
 
-        class << self
-
-          def extract_field_options(options)
-            if options && (field_name = options[:field_name]) && (field_type = options[:field_type])
-              [ field_type.to_s, field_name.to_s ]
-            elsif options && (field = options[:field])
-              [ field.type.to_s, field.name.to_s ]
-            else
-              raise ArgumentError.new "Missing options[:field_name] and/or options[:field_type]."
-            end
+      class << self
+        def extract_field_options(options)
+          if options && (field_name = options[:field_name]) && (field_type = options[:field_type])
+            [field_type.to_s, field_name.to_s]
+          elsif options && (field = options[:field])
+            [field.type.to_s, field.name.to_s]
+          else
+            raise ArgumentError.new 'Missing options[:field_name] and/or options[:field_type].'
           end
+        end
 
-          def parse_field_value(field_type, field_name, value)
-            case field_type.to_s
-            when "Moped::BSON::ObjectId" then value
-            when "String" then value.to_s
-            when "DateTime" then value.is_a?(DateTime) ? value : Time.at(value.to_i).to_datetime
-            when "Time" then value.is_a?(Time) ? value : Time.at(value.to_i)
-            when "Date" then value.is_a?(Date) ? value : 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
+        def parse_field_value(field_type, field_name, value)
+          case field_type.to_s
+          when 'BSON::ObjectId', 'Moped::BSON::ObjectId' then value
+          when 'String' then value.to_s
+          when 'DateTime' then value.is_a?(DateTime) ? value : Time.at(value.to_i).to_datetime
+          when 'Time' then value.is_a?(Time) ? value : Time.at(value.to_i)
+          when 'Date' then value.is_a?(Date) ? value : 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_type, field_name, value)
-            case field_type.to_s
-            when "Moped::BSON::ObjectId" then value
-            when "String" then value.to_s
-            when "Date" then Time.utc_time(value.year, value.month, value.day).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
+        def transform_field_value(field_type, field_name, value)
+          case field_type.to_s
+          when 'BSON::ObjectId', 'Moped::BSON::ObjectId' then value
+          when 'String' then value.to_s
+          when 'Date' then Time.utc(value.year, value.month, value.day).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

@@ -2,7 +2,6 @@ module Mongoid
   module Scroll
     module Errors
       class Base < StandardError
-
         # Problem occurred.
         attr_reader :problem
 
@@ -21,60 +20,59 @@ module Mongoid
           @summary = create_summary(key, attributes)
           @resolution = create_resolution(key, attributes)
 
-          "\nProblem:\n  #{@problem}"+
-          "\nSummary:\n  #{@summary}"+
+          "\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
+        BASE_KEY = 'mongoid.scroll.errors.messages' #:nodoc:
 
-          # 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
+        # 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 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 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 resolution.
-          #
-          # === Parameters
-          # [key] The error key.
-          # [attributes] The attributes to interpolate.
-          #
-          # Returns the resolution.
-          def create_resolution(key, attributes)
-            translate("#{key}.resolution", 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

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

@@ -2,11 +2,9 @@ module Mongoid
   module Scroll
     module Errors
       class InvalidCursorError < Mongoid::Scroll::Errors::Base
-
         def initialize(opts = {})
-          super(compose_message("invalid_cursor", opts))
+          super(compose_message('invalid_cursor', opts))
         end
-
       end
     end
   end

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

@@ -2,14 +2,12 @@ module Mongoid
   module Scroll
     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(", "))
+            opts = opts.merge(sort: opts[:sort].keys.join(', '))
           end
-          super(compose_message("multiple_sort_fields", opts))
+          super(compose_message('multiple_sort_fields', opts))
         end
-
       end
     end
   end

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

@@ -2,11 +2,9 @@ module Mongoid
   module Scroll
     module Errors
       class NoSuchFieldError < Mongoid::Scroll::Errors::Base
-
         def initialize(opts = {})
-          super(compose_message("no_such_field", opts))
+          super(compose_message('no_such_field', opts))
         end
-
       end
     end
   end

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

@@ -2,11 +2,9 @@ module Mongoid
   module Scroll
     module Errors
       class UnsupportedFieldTypeError < Mongoid::Scroll::Errors::Base
-
         def initialize(opts = {})
-          super(compose_message("unsupported_field_type", opts))
+          super(compose_message('unsupported_field_type', opts))
         end
-
       end
     end
   end

data/lib/mongoid/scroll/mongoid.rb

@@ -0,0 +1,7 @@
+module Mongoid
+  module Scroll
+    def self.mongoid3?
+      ::Mongoid.const_defined? :Observer
+    end
+  end
+end

data/lib/mongoid/scroll/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module Scroll
-    VERSION = '0.2.1'
+    VERSION = '0.3.0'
   end
 end

data/lib/mongoid-scroll.rb

@@ -1,9 +1,10 @@
 require 'i18n'
 
-I18n.load_path << File.join(File.dirname(__FILE__), "config", "locales", "en.yml")
+I18n.load_path << File.join(File.dirname(__FILE__), 'config', 'locales', 'en.yml')
 
 require 'mongoid'
 require 'mongoid/scroll/version'
+require 'mongoid/scroll/mongoid'
 require 'mongoid/scroll/errors'
 require 'mongoid/scroll/cursor'
 

data/lib/mongoid_scroll.rb

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

data/lib/moped/scrollable.rb

@@ -1,25 +1,29 @@
 module Moped
   module Scrollable
-
-    def scroll(cursor = nil, options = { field_type: Moped::BSON::ObjectId }, &block)
+    def scroll(cursor = nil, options = nil, &_block)
+      options = if Mongoid::Scroll.mongoid3?
+                  { field_type: Moped::BSON::ObjectId }
+                else
+                  { field_type: BSON::ObjectId }
+                end unless options
       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.has_key?("$orderby") || query.operation.selector["$orderby"].empty?
+      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_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)
+      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|
@@ -29,6 +33,5 @@ module Moped
         query
       end
     end
-
   end
 end

data/mongoid-scroll.gemspec

@@ -1,20 +1,18 @@
-$:.push File.expand_path("../lib", __FILE__)
-require "mongoid/scroll/version"
+$LOAD_PATH.push File.expand_path('../lib', __FILE__)
+require 'mongoid/scroll/version'
 
 Gem::Specification.new do |s|
-  s.name = "mongoid-scroll"
+  s.name = 'mongoid-scroll'
   s.version = Mongoid::Scroll::VERSION
-  s.authors = [ "Daniel Doubrovkine", "Frank Macreery" ]
-  s.email = "dblock@dblock.org"
+  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"
+  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

@@ -1,32 +1,32 @@
 require 'spec_helper'
 
 describe Mongoid::Criteria do
-  context "scrollable" do
+  context 'scrollable' do
     subject do
       Feed::Item
     end
-    it ":scroll" do
+    it ':scroll' do
       subject.should.respond_to? :scroll
     end
   end
-  context "with multiple sort fields" do
+  context 'with multiple sort fields' do
     subject do
       Feed::Item.desc(:name).asc(:value)
     end
-    it "raises Mongoid::Scroll::Errors::MultipleSortFieldsError" do
+    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./
+                                               /You're attempting to scroll over data with a sort order that includes multiple fields: name, value./
     end
   end
-  context "with no sort" do
+  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 }
+    it 'adds a default sort by _id' do
+      subject.scroll.options[:sort].should == { '_id' => 1 }
     end
   end
-  context "with data" do
+  context 'with data' do
     before :each do
       10.times do |i|
         Feed::Item.create!(
@@ -38,10 +38,10 @@ describe Mongoid::Criteria do
         )
       end
     end
-    context "default" do
-      it "scrolls all" do
+    context 'default' do
+      it 'scrolls all' do
         records = []
-        Feed::Item.all.scroll do |record, next_cursor|
+        Feed::Item.all.scroll do |record, _next_cursor|
           records << record
         end
         records.size.should == 10
@@ -50,15 +50,15 @@ describe Mongoid::Criteria do
     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
+        it 'scrolls all with a block' do
           records = []
-          Feed::Item.asc(field_name).scroll do |record, next_cursor|
+          Feed::Item.asc(field_name).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
+        it 'scrolls all with a break' do
           records = []
           cursor = nil
           Feed::Item.asc(field_name).limit(5).scroll do |record, next_cursor|
@@ -73,19 +73,19 @@ describe Mongoid::Criteria do
           records.size.should == 10
           records.should eq Feed::Item.all.to_a
         end
-        it "scrolls in descending order" do
+        it 'scrolls in descending order' do
           records = []
-          Feed::Item.desc(field_name).limit(3).scroll do |record, next_cursor|
+          Feed::Item.desc(field_name).limit(3).scroll do |record, _next_cursor|
             records << record
           end
           records.size.should == 3
           records.should eq Feed::Item.desc(field_name).limit(3).to_a
         end
-        it "map" do
-          record = Feed::Item.desc(field_name).limit(3).scroll.map { |record, cursor| record }.last
-          cursor = Mongoid::Scroll::Cursor.from_record(record, { field_type: field_type, field_name: field_name })
+        it 'map' do
+          record = Feed::Item.desc(field_name).limit(3).scroll.map { |r, _| r }.last
+          cursor = Mongoid::Scroll::Cursor.from_record(record,  field_type: field_type, field_name: field_name)
           cursor.should_not be_nil
-          cursor.to_s.split(":").should == [
+          cursor.to_s.split(':').should == [
             Mongoid::Scroll::Cursor.transform_field_value(field_type, field_name, record.send(field_name)).to_s,
             record.id.to_s
           ]
@@ -93,18 +93,18 @@ describe Mongoid::Criteria do
       end
     end
   end
-  context "with overlapping data" do
+  context 'with overlapping data' 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
+    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
-      Feed::Item.order_by("$natural" => 1).to_a.should_not eq Feed::Item.order_by(_id: 1).to_a
+      Feed::Item.order_by('$natural' => 1).to_a.should_not eq Feed::Item.order_by(_id: 1).to_a
     end
-    [ { a_integer: 1 }, { a_integer: -1 }].each do |sort_order|
+    [{ a_integer: 1 }, { a_integer: -1 }].each do |sort_order|
       it "scrolls by #{sort_order}" do
         records = []
         cursor = nil
@@ -113,7 +113,7 @@ describe Mongoid::Criteria do
           cursor = next_cursor
         end
         records.size.should == 2
-        Feed::Item.order_by(sort_order).scroll(cursor) do |record, next_cursor|
+        Feed::Item.order_by(sort_order).scroll(cursor) do |record, _next_cursor|
           records << record
         end
         records.size.should == 3

data/spec/mongoid/scroll_cursor_spec.rb

@@ -1,120 +1,120 @@
 require 'spec_helper'
 
 describe Mongoid::Scroll::Cursor do
-  context "an empty cursor" do
+  context 'an empty cursor' do
     subject do
-      Mongoid::Scroll::Cursor.new nil, field_name: "a_string", field_type: String
+      Mongoid::Scroll::Cursor.new nil, field_name: 'a_string', field_type: 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_name: "a_string", field_type: String }.to raise_error Mongoid::Scroll::Errors::InvalidCursorError,
-        /The cursor supplied is invalid: invalid./
+  context 'an invalid cursor' do
+    it 'raises InvalidCursorError' do
+      expect { Mongoid::Scroll::Cursor.new 'invalid', field_name: 'a_string', field_type: 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") }
+  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_name: "a_string", field_type: String
+      Mongoid::Scroll::Cursor.new "#{feed_item.a_string}:#{feed_item.id}", field_name: 'a_string', field_type: 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 }}
-      ]})
+      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
+  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_name: "a_integer", field_type: Integer
+      Mongoid::Scroll::Cursor.new "#{feed_item.a_integer}:#{feed_item.id}", field_name: 'a_integer', field_type: 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 }}
-      ]})
+      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
+  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_name: "a_datetime", field_type: DateTime
+      Mongoid::Scroll::Cursor.new "#{feed_item.a_datetime.to_i}:#{feed_item.id}", field_name: 'a_datetime', field_type: 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 }}
-      ]})
+      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
+  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_name: "a_date", field_type: Date
+      Mongoid::Scroll::Cursor.new "#{feed_item.a_date.to_datetime.to_i}:#{feed_item.id}", field_name: 'a_date', field_type: 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 }}
-      ]})
+      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
+  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_name: "a_time", field_type: Time
+      Mongoid::Scroll::Cursor.new "#{feed_item.a_time.to_i}:#{feed_item.id}", field_name: 'a_time', field_type: 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 }}
-      ]})
+      should eq('$or' => [
+        { 'a_time' => { '$gt' => feed_item.a_time } },
+        { 'a_time' => feed_item.a_time, :_id => { '$gt' => feed_item.id } }
+      ])
     }
   end
-  context "a time field cursor with a field option" do
+  context 'a time field cursor with a field option' 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"]
+      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 }}
-      ]})
+      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
+  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_name: "a_array", field_type: Array
+        Mongoid::Scroll::Cursor.from_record feed_item, field_name: 'a_array', field_type: 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
+  context 'an invalid field cursor' do
+    it 'raises ArgumentError' do
       expect {
-        Mongoid::Scroll::Cursor.new "invalid:whatever", {}
+        Mongoid::Scroll::Cursor.new 'invalid:whatever', {}
       }.to raise_error ArgumentError
     end
   end

data/spec/mongoid/scroll_spec.rb

@@ -3,4 +3,3 @@ require 'spec_helper'
 describe Mongoid::Scroll::VERSION do
   it { should_not be_nil }
 end
-

data/spec/moped/query_spec.rb

@@ -1,32 +1,32 @@
 require 'spec_helper'
 
 describe Moped::Query do
-  context "scrollable" do
+  context 'scrollable' do
     subject do
       Mongoid.default_session['feed_items'].find
     end
-    it ":scroll" do
+    it ':scroll' do
       subject.should.respond_to? :scroll
     end
   end
-  context "with multiple sort fields" do
+  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
+    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./
+                                               /You're attempting to scroll over data with a sort order that includes multiple fields: name, value./
     end
   end
-  context "with no sort" do
+  context 'with no sort' do
     subject do
       Mongoid.default_session['feed_items'].find
     end
-    it "adds a default sort by _id" do
-      subject.scroll.operation.selector["$orderby"].should == { _id: 1 }
+    it 'adds a default sort by _id' do
+      subject.scroll.operation.selector['$orderby'].should == { _id: 1 }
     end
   end
-  context "with data" do
+  context 'with data' do
     before :each do
       10.times do |i|
         Mongoid.default_session['feed_items'].insert(
@@ -38,10 +38,10 @@ describe Moped::Query do
         )
       end
     end
-    context "default" do
-      it "scrolls all" do
+    context 'default' do
+      it 'scrolls all' do
         records = []
-        Mongoid.default_session['feed_items'].find.scroll do |record, next_cursor|
+        Mongoid.default_session['feed_items'].find.scroll do |record, _next_cursor|
           records << record
         end
         records.size.should == 10
@@ -50,63 +50,63 @@ describe Moped::Query do
     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
+        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|
+          Mongoid.default_session['feed_items'].find.sort(field_name => 1).scroll(nil,  field_type: field_type) do |record, _next_cursor|
             records << record
           end
           records.size.should == 10
           records.should eq Mongoid.default_session['feed_items'].find.to_a
         end
-        it "scrolls all with a break" do
+        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|
+          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
           records.size.should == 5
-          Mongoid.default_session['feed_items'].find.sort(field_name => 1).scroll(cursor, { field_type: field_type }) do |record, next_cursor|
+          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
           records.size.should == 10
           records.should eq Mongoid.default_session['feed_items'].find.to_a
         end
-        it "scrolls in descending order" do
+        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|
+          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
           records.size.should == 3
           records.should 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 {
-            |record, cursor| record
+        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 })
+          cursor = Mongoid::Scroll::Cursor.from_record(record,  field_type: field_type, field_name: field_name)
           cursor.should_not be_nil
-          cursor.to_s.split(":").should == [
+          cursor.to_s.split(':').should == [
             Mongoid::Scroll::Cursor.transform_field_value(field_type, field_name, record[field_name.to_s]).to_s,
-            record["_id"].to_s
+            record['_id'].to_s
           ]
         end
       end
     end
   end
-  context "with overlapping data" do
+  context 'with overlapping data' 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
+    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
-      Feed::Item.order_by("$natural" => 1).to_a.should_not eq Feed::Item.order_by(_id: 1).to_a
+      Feed::Item.order_by('$natural' => 1).to_a.should_not eq Feed::Item.order_by(_id: 1).to_a
     end
-    [ { a_integer: 1 }, { a_integer: -1 }].each do |sort_order|
+    [{ a_integer: 1 }, { a_integer: -1 }].each do |sort_order|
       it "scrolls by #{sort_order}" do
         records = []
         cursor = nil
@@ -115,7 +115,7 @@ describe Moped::Query do
           cursor = next_cursor
         end
         records.size.should == 2
-        Mongoid.default_session['feed_items'].find.sort(sort_order).scroll(cursor) do |record, next_cursor|
+        Mongoid.default_session['feed_items'].find.sort(sort_order).scroll(cursor) do |record, _next_cursor|
           records << record
         end
         records.size.should == 3

data/spec/spec_helper.rb

@@ -18,4 +18,3 @@ RSpec.configure do |config|
     Mongoid.purge!
   end
 end
-

data/spec/support/feed/item.rb

@@ -2,6 +2,7 @@ module Feed
   class Item
     include Mongoid::Document
 
+    field :name, type: String
     field :a_integer, type: Integer
     field :a_string, type: String
     field :a_datetime, type: DateTime

metadata

@@ -1,8 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid-scroll
 version: !ruby/object:Gem::Version
-  version: 0.2.1
-  prerelease: 
+  version: 0.3.0
 platform: ruby
 authors:
 - Daniel Doubrovkine
@@ -10,38 +9,34 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-02-21 00:00:00.000000000 Z
+date: 2014-07-02 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: 
@@ -52,6 +47,7 @@ extra_rdoc_files: []
 files:
 - .gitignore
 - .rspec
+- .rubocop.yml
 - .travis.yml
 - CHANGELOG.md
 - Gemfile
@@ -70,6 +66,7 @@ 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/mongoid.rb
 - lib/mongoid/scroll/version.rb
 - lib/mongoid_scroll.rb
 - lib/moped/scrollable.rb
@@ -83,29 +80,25 @@ files:
 homepage: http://github.com/dblock/mongoid-scroll
 licenses:
 - MIT
+metadata: {}
 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: -2452181324971075888
 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
+rubygems_version: 2.1.11
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Mongoid extensions to enable infinite scroll.
 test_files: []