mongoid_spacial 0.1.1 → 0.2.0

data/Gemfile

@@ -24,6 +24,7 @@ group :test, :development do
 end
 
 group :test do
+  gem 'rspec-rails'
   gem 'mocha'
   gem 'will_paginate'
   gem 'kaminari'

data/README.md

@@ -89,7 +89,6 @@ One of the most handy features we have added is geo_near finder
 
 ```ruby
 # accepts all criteria chains except without, only, asc, desc, order\_by
-# pagination does not work yet but will be added in the next version
 River.where(:name=>'hudson').geo_near({:lat => 40.73083, :lng => -73.99756})
 
 # geo\_near accepts a few parameters besides a point
@@ -99,13 +98,47 @@ River.where(:name=>'hudson').geo_near({:lat => 40.73083, :lng => -73.99756})
 # :max\_distance - Integer
 # :distance\_multiplier - Integer
 # :spherical - true - To enable spherical calculations
+River.geo_near([-73.99756,40.73083], :max_distance => 4, :unit => :mi, :spherical => true)
+```
+
+There are two types of pagination!
+
+* MongoDB Pagination - Stores start of rows to page limit in memory
+* Post Query Pagination - Stores all rows in memory
+
+Post-Result is only minutely slower than MongoDB because MongoDB has to calculate distance for all of the rows anyway. The slow up is in the transfer of data from the database to ruby.
+
+Post-Result has some advantages that are listed below.
+
+```ruby
+# MongoDB pagination
+# overwrites #skip chain method
 # :page - pagination will be enabled if set to any variable including nil, pagination will not be enabled if either :per\_page or :paginator is set
 #   :per\_page
 #   :paginator - Choose which paginator to use. [default :arrary]
 #     Prefered method to set is Mongoid::Spacial.paginator=:array
 #     Available Paginators [:kaminari, :will\_paginate, :array]
 #     The only thing this does really is configure default per\_page so it is only kind of useful
-River.geo_near([-73.99756,40.73083], :max_distance => 4, :unit => :mi, :spherical => true, :page => 1)
+River.geo_near([-73.99756,40.73083], :page => 1)
+```
+
+```ruby
+# Post Query Pagination
+# At carzen we use Post Query Pagination because we need to re-sort our rows after fetching. Pagination is not friendly with re-sorting.
+# You can jump pages continously without querying the database again.
+# listens to #limit/:num & #skip before geo\_near
+# #page(page\_number, opts = {})
+#  opts:
+#   :per\_page
+#   :paginator 
+# #per(per\_page\_number, opts = {})
+#  opts:
+#   :page
+#   :paginator
+#
+# both return a GeoNearResults, which is really just a modified Array
+# #per really just #page but just moves the options around 
+River.geo_near([-73.99756,40.73083]).per(25).page(1)
 ```
 
 Thanks

data/VERSION

@@ -1 +1 @@
-0.1.1
+0.2.0

data/lib/mongoid_spacial/contexts/mongo.rb

@@ -36,26 +36,31 @@ module Mongoid #:nodoc:
         center = center.to_lng_lat if center.respond_to?(:to_lng_lat)
 
         # set default opts
-        if distance_multiplier = Mongoid::Spacial.earth_radius[opts.delete(:unit)]
-          opts[:distance_multiplier] = distance_multiplier
+        opts[:skip] ||= 0
+        
+        if unit = Mongoid::Spacial.earth_radius[opts[:unit]]
+          opts[:unit] = (opts[:spherical]) ? unit : unit * Mongoid::Spacial::RAD_PER_DEG
         end
+
+        opts[:distance_multiplier] = opts[:unit] if opts[:unit].kind_of?(Numeric)
   
         # setup paging.
         if opts.has_key?(:page)
           opts[:page] ||= 1
           opts[:paginator] ||= Mongoid::Spacial.paginator()
 
-          if opts[:paginator] == :will_paginate
-            opts[:per_page] ||= klass.per_page
-          elsif opts[:paginator] == :kaminari
-            opts[:per_page] ||= Kaminari.config.default_per_page
-          else
-            opts[:per_page] ||= Mongoid::Spacial.default_per_page
-          end
+          opts[:per_page] ||= case opts[:paginator]
+                              when :will_paginate
+                                @document.per_page
+                              when :kaminari
+                                Kaminari.config.default_per_page
+                              else
+                                Mongoid::Spacial.default_per_page
+                              end
         end
-        query = create_geo_near_query(center,opts)
-        results = klass.db.command(query)
-        Mongoid::Spacial::GeoNear.new(klass,results,opts)
+        opts[:query] = create_geo_near_query(center,opts)
+        results = klass.db.command(opts[:query])
+        Mongoid::Spacial::GeoNearResults.new(klass,results,opts)
       end
 
       private
@@ -69,11 +74,11 @@ module Mongoid #:nodoc:
 
         # create limit and use skip
         if opts[:num]
-          query['num']         = (opts[:skip] || 0) + opts[:num].to_i
+          query['num']         = opts[:skip] + opts[:num].to_i
         elsif opts[:limit]
-          query['num']         = (opts[:skip] || 0) + opts[:limit]
+          query['num']         = opts[:skip] + opts[:limit]
         elsif opts[:page]
-          query['num'] = (opts[:page] * opts[:per_page])
+          query['num'] = opts[:skip] +(opts[:page] * opts[:per_page])
         end
 
         # allow the use of complex werieis
@@ -85,7 +90,7 @@ module Mongoid #:nodoc:
 
         if opts[:max_distance]
           query['maxDistance'] = opts[:max_distance]
-          query['maxDistance'] = query['maxDistance']/opts[:distance_multiplier] if opts[:distance_multiplier]
+          query['maxDistance'] = query['maxDistance']/opts[:unit] if opts[:unit]
         end
 
         if klass.db.connection.server_version >= '1.7'

data/lib/mongoid_spacial/criterion.rb

@@ -1,8 +1,3 @@
 require 'mongoid_spacial/criterion/complex'
-# encoding: utf-8
-module Mongoid #:nodoc:
-  module Criterion #:nodoc:
-    autoload :NearSpacial,     'mongoid_spacial/criterion/near_spacial'
-    autoload :WithinSpacial,    'mongoid_spacial/criterion/within_spacial'
-  end
-end
+require 'mongoid_spacial/criterion/near_spacial'
+require 'mongoid_spacial/criterion/within_spacial'

data/lib/mongoid_spacial/field_option.rb

@@ -4,8 +4,8 @@ field = (defined?(Mongoid::Field)) ? Mongoid::Field : Mongoid::Fields
 
 field.option :spacial do |model,field,options|
   options = {} unless options.kind_of?(Hash)
-  lat_meth = options[:lat] || "lat"
-  lng_meth = options[:lng] || "lng"
+  lat_meth = options[:lat] || :lat
+  lng_meth = options[:lng] || :lng
   model.class_eval do
     self.spacial_fields ||= []
     self.spacial_fields << field.name.to_sym if self.spacial_fields.kind_of? Array

data/lib/mongoid_spacial/spacial/formulas.rb

@@ -1,7 +1,6 @@
 module Mongoid
   module Spacial
     module Formulas
-      RAD_PER_DEG = Math::PI/180
 
       def self.n_vector(point1,point2)
         p1 = point1.map{|deg| deg * RAD_PER_DEG}

data/lib/mongoid_spacial/spacial/geo_near_results.rb

@@ -0,0 +1,123 @@
+module Mongoid
+  module Spacial
+    class GeoNearResults < Array
+      attr_reader :stats, :document, :_original_array
+      attr_accessor :opts
+
+      def initialize(document,results,opts = {})
+        raise "class must include Mongoid::Spacial::Document" unless document.respond_to?(:spacial_fields_indexed)
+        @document = document
+        @opts = opts
+        @stats = results['stats'] || {}
+        @opts[:skip] ||= 0
+        @opts[:total_entries] = opts[:query]["num"] || @stats['nscanned']
+        @limit_value = opts[:per_page]
+        @current_page = opts[:page]
+
+        @_original_array = results['results'].collect do |result|
+          res = Mongoid::Factory.from_db(@document, result.delete('obj'))
+          res.geo = {}
+          # camel case is awkward in ruby when using variables...
+          if result['dis']
+            res.geo[:distance] = result.delete('dis').to_f
+          end
+          result.each do |key,value|
+            res.geo[key.snakecase.to_sym] = value
+          end
+          # dist_options[:formula] = opts[:formula] if opts[:formula]
+          @opts[:calculate] = @document.spacial_fields_indexed if @document.spacial_fields_indexed.kind_of?(Array) && @opts[:calculate] == true
+          if @opts[:calculate]
+            @opts[:calculate] = [@opts[:calculate]] unless @opts[:calculate].kind_of? Array
+            @opts[:calculate] = @opts[:calculate].map(&:to_sym) & geo_fields
+            if @document.spacial_fields_indexed.kind_of?(Array) && @document.spacial_fields_indexed.size == 1
+              primary = @document.spacial_fields_indexed.first
+            end
+            @opts[:calculate].each do |key|
+              key = (key.to_s+'_distance').to_sym
+              res.geo[key] = res.distance_from(key,center, @opts[:distance_multiplier])
+              res.geo[:distance] = res.geo[key] if primary && key == primary
+            end
+          end
+          res
+        end
+
+        if @opts[:page]
+          start = (@opts[:page]-1)*@opts[:per_page] # assuming current_page is 1 based.
+          super(@_original_array[@opts[:skip]+start, @opts[:per_page]] || [])
+        else
+          super(@_original_array[@opts[:skip]..-1] || [])
+        end
+      end
+
+      def page(page, options = {})
+        new_collection = self.dup
+        
+        options = self.opts.merge(options)
+
+        options[:page] = page || 1
+
+        options[:paginator] ||= Mongoid::Spacial.paginator()
+
+        options[:per_page] ||= case options[:paginator]
+                            when :will_paginate
+                              @document.per_page
+                            when :kaminari
+                              Kaminari.config.default_per_page
+                            else
+                              Mongoid::Spacial.default_per_page
+                            end
+
+
+        start = (options[:page]-1)*options[:per_page] # assuming current_page is 1 based.
+        new_collection.replace(@_original_array[@opts[:skip]+start, options[:per_page]] || [])
+
+        new_collection.opts[:page] = options[:page]
+        new_collection.opts[:paginator] = options[:paginator]
+        new_collection.opts[:per_page] = options[:per_page]
+
+        new_collection
+      end
+
+      def per(num)
+        self.page(current_page, :per_page => num)
+      end
+
+      def total_entries
+        @opts[:total_entries]
+      end
+
+      def current_page
+        @opts[:page]
+      end
+
+      def limit_value
+        @opts[:per_page]
+      end
+      alias_method :per_page, :limit_value
+
+      def num_pages
+        @opts[:total_entries]/@opts[:per_page]
+      end
+      alias_method :total_pages, :num_pages
+
+      def out_of_bounds?
+        self.current_page > self.total_pages
+      end
+
+      def offset
+        (self.current_page - 1) * self.per_page
+      end
+
+      # current_page - 1 or nil if there is no previous page
+      def previous_page
+        self.current_page > 1 ? (self.current_page - 1) : nil
+      end
+
+      # current_page + 1 or nil if there is no next page
+      def next_page
+        self.current_page < self.total_pages ? (self.current_page + 1) : nil
+      end
+
+    end
+  end
+end

data/lib/mongoid_spacial/spacial.rb

@@ -1,9 +1,9 @@
 require 'mongoid_spacial/spacial/core_ext'
 require 'mongoid_spacial/spacial/formulas'
+require 'mongoid_spacial/spacial/document'
+require 'mongoid_spacial/spacial/geo_near_results'
 module Mongoid
   module Spacial
-    autoload :Document,          'mongoid_spacial/spacial/document'
-    autoload :GeoNear,           'mongoid_spacial/spacial/geo_near'
 
     EARTH_RADIUS_KM = 6371 # taken directly from mongodb
 
@@ -14,15 +14,18 @@ module Mongoid
       :ft => EARTH_RADIUS_KM*5280*0.621371192,
     }
 
+    RAD_PER_DEG = Math::PI/180
+
     LNG_SYMBOLS = [:x, :lon, :long, :lng, :longitude]
     LAT_SYMBOLS = [:y, :lat, :latitude]
 
-    def distance(p1,p2,unit = nil, formula = nil)
+    def self.distance(p1,p2,unit = nil, formula = nil)
       formula ||= self.distance_formula
       unit = earth_radius[unit] if unit.kind_of?(Symbol) && earth_radius[unit]
       rads = Formulas.send(formula, p1, p2)
       (unit.kind_of?(Numeric)) ? unit*rads : rads
     end
+
     mattr_accessor :lng_symbols
     @@lng_symbols = LNG_SYMBOLS.dup
 
@@ -35,8 +38,8 @@ module Mongoid
     mattr_accessor :distance_formula
     @@distance_formula = :n_vector
 
-    mattr_accessor :paginator
-    @@paginator = :array
+      mattr_accessor :paginator
+      @@paginator = :array
 
     mattr_accessor :default_per_page
     @@default_per_page = 25

data/mongoid_spacial.gemspec

@@ -5,7 +5,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{mongoid_spacial}
-  s.version = "0.1.1"
+  s.version = "0.2.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = [%q{Ryan Ong}]
@@ -40,12 +40,13 @@ Gem::Specification.new do |s|
     "lib/mongoid_spacial/spacial/core_ext.rb",
     "lib/mongoid_spacial/spacial/document.rb",
     "lib/mongoid_spacial/spacial/formulas.rb",
-    "lib/mongoid_spacial/spacial/geo_near.rb",
+    "lib/mongoid_spacial/spacial/geo_near_results.rb",
     "mongoid_spacial.gemspec",
     "spec/config/mongod.conf",
     "spec/config/mongoid.yml",
     "spec/functional/mongoid/contexts/mongo_spec.rb",
     "spec/functional/mongoid/criterion/inclusion_spec.rb",
+    "spec/functional/mongoid/spacial/geo_near_results_spec.rb",
     "spec/models/account.rb",
     "spec/models/acolyte.rb",
     "spec/models/address.rb",

data/spec/functional/mongoid/contexts/mongo_spec.rb

@@ -86,18 +86,18 @@ describe Mongoid::Contexts::Mongo do
       Bar.delete_all
       Bar.create_indexes
 
-      100.times do
+      50.times do
         Bar.create({:location => [rand(360)-180,rand(360)-180]})
       end
     end
     context ":paginator :array" do
-      [nil,1,2,3,4].each do |page|          
+      [nil,1,2].each do |page|          
         it "page=#{page} should have 25" do
           Bar.geo_near([1,1], :page => page).size.should == 25
         end
       end
 
-      it "page=20 should have 0" do
+      it "page=3 should have 0" do
         Bar.geo_near([1,1], :page => 20).size.should == 0
       end
       
@@ -105,7 +105,21 @@ describe Mongoid::Contexts::Mongo do
         Bar.geo_near([1,1], :page => 1, :per_page => 5).size.should == 5
       end
     end
+
+    context ":paginator :kaminari" do 
+      let(:near) {Bar.geo_near([1,1], :page => 1)}
+      it "should have current_page" do
+        near.current_page.should == 1
+      end
+
+      it "should have num_pages" do
+        near.num_pages.should == 2
+      end
+
+      it "should have limit_value" do
+        near.limit_value.should == 25
+      end
+    end      
   end
 
 end
-

data/spec/functional/mongoid/spacial/geo_near_results_spec.rb

@@ -0,0 +1,45 @@
+require "spec_helper"
+
+describe Mongoid::Spacial::GeoNearResults do
+  before(:all) do
+    Bar.delete_all
+    Bar.create_indexes
+
+    50.times do
+      Bar.create({:location => [rand(360)-180,rand(360)-180]})
+    end
+    while Bar.count < 50
+    end
+  end
+  context ":paginator :array" do
+    [nil,1,2].each do |page|          
+      it "page=#{page} should have 25" do
+        Bar.geo_near([1,1]).page(page).size.should == 25
+      end
+    end
+
+    it "page=3 should have 0" do
+      Bar.geo_near([1,1]).page(3).size.should == 0
+    end
+
+    it "per=5" do
+      Bar.geo_near([1,1]).per(5).size.should == 5
+    end
+  end
+
+  context ":paginator :kaminari" do 
+    let!(:near) {Bar.geo_near([1,1]).page(1)}
+    it "should have current_page" do
+      near.current_page.should == 1
+    end
+
+    it "should have num_pages" do
+      near.total_entries.should == 50
+      near.num_pages.should == 2
+    end
+
+    it "should have limit_value" do
+      near.limit_value.should == 25
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -10,10 +10,13 @@ require "mongoid"
 require "mocha"
 require "rspec"
 require "mongoid_spacial"
-require 'ruby-debug'
 
 LOGGER = Logger.new($stdout)
 
+if RUBY_VERSION >= '1.9.2'
+  YAML::ENGINE.yamler = 'syck'
+end
+
 Mongoid.configure do |config|
   name = "mongoid_spacial_test"
   config.master = Mongo::Connection.new.db(name)
@@ -35,7 +38,6 @@ RSpec.configure do |config|
   warn(Support::Authentication.message) unless user_configured
 
   config.filter_run_excluding(:config => lambda { |value|
-    return true if value == :mongohq && !mongohq_configured
     return true if value == :user && !user_configured
   })
 end

metadata

@@ -2,7 +2,7 @@
 name: mongoid_spacial
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors: 
 - Ryan Ong
@@ -166,12 +166,13 @@ files:
 - lib/mongoid_spacial/spacial/core_ext.rb
 - lib/mongoid_spacial/spacial/document.rb
 - lib/mongoid_spacial/spacial/formulas.rb
-- lib/mongoid_spacial/spacial/geo_near.rb
+- lib/mongoid_spacial/spacial/geo_near_results.rb
 - mongoid_spacial.gemspec
 - spec/config/mongod.conf
 - spec/config/mongoid.yml
 - spec/functional/mongoid/contexts/mongo_spec.rb
 - spec/functional/mongoid/criterion/inclusion_spec.rb
+- spec/functional/mongoid/spacial/geo_near_results_spec.rb
 - spec/models/account.rb
 - spec/models/acolyte.rb
 - spec/models/address.rb
@@ -261,7 +262,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: 3825965172872748297
+      hash: -931697683295411699
       segments: 
       - 0
       version: "0"

data/lib/mongoid_spacial/spacial/geo_near.rb

@@ -1,86 +0,0 @@
-module Mongoid
-  module Spacial
-    class GeoNear < Array
-      attr_reader :stats
-
-      def initialize(klass,results,opts = {})
-        raise "class must include Mongoid::Spacial::Document" unless klass.respond_to?(:spacial_fields_indexed)
-        @klass = klass
-        @opts = opts
-        @stats = results['stats']
-
-        @_original_array = results['results'].collect do |result|
-          res = Mongoid::Factory.from_db(klass, result.delete('obj'))
-          res.geo = {}
-          # camel case is awkward in ruby when using variables...
-          if result['dis']
-            res.geo[:distance] = result.delete('dis').to_f
-          end
-          result.each do |key,value|
-            res.geo[key.snakecase.to_sym] = value
-          end
-          # dist_options[:formula] = opts[:formula] if opts[:formula]
-          @opts[:calculate] = klass.spacial_fields_indexed if klass.spacial_fields_indexed.kind_of?(Array) && @opts[:calculate] == true
-          if @opts[:calculate]
-            @opts[:calculate] = [@opts[:calculate]] unless @opts[:calculate].kind_of? Array
-            @opts[:calculate] = @opts[:calculate].map(&:to_sym) & geo_fields
-            if klass.spacial_fields_indexed.kind_of?(Array) && klass.spacial_fields_indexed.size == 1
-              primary = klass.spacial_fields_indexed.first
-            end
-            @opts[:calculate].each do |key|
-              key = (key.to_s+'_distance').to_sym
-              res.geo[key] = res.distance_from(key,center, @opts[:distance_multiplier])
-              res.geo[:distance] = res.geo[key] if primary && key == primary
-            end
-          end
-          res
-        end
-
-        if @opts[:page]
-          start = (@opts[:page]-1)*@opts[:per_page] # assuming current_page is 1 based.
-          super(@_original_array[start, @opts[:per_page]] || [])
-        elsif @opts[:skip] && @_original_array.size > @opts[:skip]
-          super(@_original_array[@opts[:skip]..-1] || [])
-        else
-          super(@_original_array || [])
-        end
-      end
-
-      def current_page
-        @opts[:page]
-      end
-
-      def num_pages
-        @stats['nscanned']/@opts[:per_page]
-      end
-      alias_method :total_pages, :num_pages
-
-      def out_of_bounds?
-        current_page > total_pages
-      end
-
-      def limit_value
-        @opts[:per_page]
-      end
-      alias_method :per_page, :limit_value
-
-      def offset
-        (current_page - 1) * per_page
-      end
-
-      # current_page - 1 or nil if there is no previous page
-      def previous_page
-        current_page > 1 ? (current_page - 1) : nil
-      end
-
-      # current_page + 1 or nil if there is no next page
-      def next_page
-        current_page < total_pages ? (current_page + 1) : nil
-      end
-
-      def total_entries
-        @stats['nscanned']
-      end
-    end
-  end
-end