mongoid_location 0.3.1 → 0.3.2

data/lib/mongoid_location.rb

@@ -2,13 +2,13 @@ require 'rgeo'
 require 'mongoid'
 require 'active_support/core_ext/string/inflections'
 require 'active_support/concern'
+require 'mongoid_location/version'
+#require 'mongoid_location/contextual/mongo'
 if Mongoid::VERSION > '3'
   require 'mongoid_location/contextual/mongo'
 else
   require 'mongoid_location/contexts/mongo'
 end
-require 'mongoid_location/version'
-#require 'mongoid_location/contextual/mongo'
 require 'mongoid_location/criteria'
 require 'mongoid_location/extensions/symbol'
 require 'mongoid_location/extensions/rgeo_spherical_point_impl'

data/lib/mongoid_location/contexts/mongo.rb

@@ -0,0 +1,117 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Contexts #:nodoc:
+    class Mongo #:nodoc:
+
+      # Fetches rows from the data base sorted by distance.
+      # In MongoDB versions 1.7 and above it returns a distance.
+      # Uses all criteria chains except without, only, asc, desc, order_by
+      #
+      # @example Minimal Query
+      #
+      #   Address.geo_near([70,40])
+      #
+      # @example Chained Query
+      #
+      #   Address.where(:state => 'ny').geo_near([70,40])
+      #
+      # @example Calc Distances Query
+      #
+      #   Address.geo_near([70,40], :max_distance => 5, :unit => 5)
+      #
+      # @param [ Array, Hash, #to_xy ] center The center of where to calculate distance from
+      # @param [ Hash ] opts the options to query with
+      # @options opts [Integer] :num The number of rows to fetch
+      # @options opts [Hash] :query The query to filter the rows by, accepts
+      # @options opts [Numeric] :distance_multiplier this is multiplied against the calculated distance
+      # @options opts [Numeric] :max_distance The max distance of a row that should be returned in :unit(s)
+      # @options opts [Numeric, :km, :k, :mi, :ft] :unit automatically sets :distance_multiplier and converts :max_distance
+      # @options opts [true,false] :spherical Will determine the distance either by spherical calculation or flat calculation
+      # @options opts [TrueClass,Array<Symbol>] :calculate Which extra fields to calculate distance for in ruby, if set to TrueClass it will calculate all spatial fields
+      #
+      # @return [ Array ] Sorted Rows
+      def geo_near(center, opts = {})
+        opts = self.options.merge(opts)
+        # convert point
+        center = center.to_xy if center.respond_to?(:to_xy)
+        center = [center.x, center.y] if center.respond_to?(:x)
+
+        # set default opts
+        opts[:skip] ||= 0
+
+        if unit = Mongoid::Location.earth_radius[opts[:unit]]
+          opts[:unit] = (opts[:spherical]) ? unit : unit * Mongoid::Location::RAD_PER_DEG
+        end
+
+        if unit = Mongoid::Location.earth_radius[opts[:distance_multiplier]]
+          opts[:distance_multiplier] = (opts[:spherical]) ? unit : unit * Mongoid::Location::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::Location.paginator()
+
+           if opts[:per_page].blank?
+             opts[:per_page] = case opts[:paginator]
+                              when :will_paginate
+                                @document.per_page
+                              when :kaminari
+                                Kaminari.config.default_per_page
+                              else
+                                Mongoid::Location.default_per_page
+                              end
+             opts[:per_page] = opts[:per_page].to_i
+           end
+
+        end
+        opts[:query] = create_geo_near_query(center,opts)
+        results = klass.db.command(opts[:query])
+        Mongoid::Location::GeoNearResults.new(klass,results,opts)
+      end
+
+      private
+
+      def create_geo_near_query(center,opts)
+        # minimum query
+        query = BSON::OrderedHash.new
+        query[:geoNear] = klass.collection_name
+        query[:near] = center
+
+        # create limit and use skip
+        if opts[:num]
+          query['num']         = opts[:skip].to_i + opts[:num].to_i
+        elsif opts[:limit]
+          query['num']         = opts[:skip].to_i + opts[:limit].to_i
+        elsif opts[:page]
+          query['num'] = opts[:skip].to_i + (opts[:page].to_i * opts[:per_page].to_i)
+        end
+
+        # allow the use of complex werieis
+        if opts[:query]
+          query['query']         = self.criteria.where(opts[:query]).selector
+        elsif self.selector != {}
+          query['query']         = self.selector
+        end
+
+        if opts[:max_distance]
+          query['maxDistance'] = opts[:max_distance].to_f
+          query['maxDistance'] = query['maxDistance']/opts[:unit].to_f if opts[:unit]
+        end
+
+        if opts[:unique_docs]
+           query['uniqueDocs'] = true
+        end
+
+        query['spherical']  = true if opts[:spherical]
+
+        # mongodb < 1.7 returns degrees but with earth flat. in Mongodb 1.7 you can set sphere and let mongodb calculate the distance in Miles or KM
+        # for mongodb < 1.7 we need to run Haversine first before calculating degrees to Km or Miles. See below.
+        query['distanceMultiplier'] = opts[:distance_multiplier].to_f if opts[:distance_multiplier]
+        query
+      end
+    end
+  end
+end

data/lib/mongoid_location/contextual/mongo.rb

@@ -0,0 +1,118 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Contextual #:nodoc:
+    class Mongo #:nodoc:
+
+      # Fetches rows from the data base sorted by distance.
+      # In MongoDB versions 1.7 and above it returns a distance.
+      # Uses all criteria chains except without, only, asc, desc, order_by
+      #
+      # @example Minimal Query
+      #
+      #   Address.geo_near([70,40])
+      #
+      # @example Chained Query
+      #
+      #   Address.where(:state => 'ny').geo_near([70,40])
+      #
+      # @example Calc Distances Query
+      #
+      #   Address.geo_near([70,40], :max_distance => 5, :unit => 5)
+      #
+      # @param [ Array, Hash, #to_xy ] center The center of where to calculate distance from
+      # @param [ Hash ] opts the options to query with
+      # @options opts [Integer] :num The number of rows to fetch
+      # @options opts [Hash] :query The query to filter the rows by, accepts
+      # @options opts [Numeric] :distance_multiplier this is multiplied against the calculated distance
+      # @options opts [Numeric] :max_distance The max distance of a row that should be returned in :unit(s)
+      # @options opts [Numeric, :km, :k, :mi, :ft] :unit automatically sets :distance_multiplier and converts :max_distance
+      # @options opts [true,false] :spherical Will determine the distance either by spherical calculation or flat calculation
+      # @options opts [TrueClass,Array<Symbol>] :calculate Which extra fields to calculate distance for in ruby, if set to TrueClass it will calculate all spatial fields
+      #
+      # @return [ Array ] Sorted Rows
+      def geo_near(center, opts = {})
+        opts = self.criteria.options.merge(opts)
+        # convert point
+        center = center.to_xy if center.respond_to?(:to_xy)
+        center = [center.x, center.y] if center.respond_to?(:x)
+
+        # set default opts
+        opts[:skip] ||= 0
+
+        if unit = Mongoid::Location.earth_radius[opts[:unit]]
+          opts[:unit] = (opts[:spherical]) ? unit : unit * Mongoid::Location::RAD_PER_DEG
+        end
+
+        if unit = Mongoid::Location.earth_radius[opts[:distance_multiplier]]
+          opts[:distance_multiplier] = (opts[:spherical]) ? unit : unit * Mongoid::Location::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::Location.paginator()
+
+           if opts[:per_page].blank?
+             opts[:per_page] = case opts[:paginator]
+                              when :will_paginate
+                                @document.per_page
+                              when :kaminari
+                                Kaminari.config.default_per_page
+                              else
+                                Mongoid::Location.default_per_page
+                              end
+             opts[:per_page] = opts[:per_page].to_i
+           end
+
+        end
+        opts[:query] = create_geo_near_query(center,opts)
+        results = klass.mongo_session.command(opts[:query])
+        
+        Mongoid::Location::GeoNearResults.new(klass,results,opts)
+      end
+
+      private
+
+      def create_geo_near_query(center,opts)
+        # minimum query
+        query = {}
+        query[:geoNear] = klass.collection_name
+        query[:near] = center
+
+        # create limit and use skip
+        if opts[:num]
+          query['num']         = opts[:skip].to_i + opts[:num].to_i
+        elsif opts[:limit]
+          query['num']         = opts[:skip].to_i + opts[:limit].to_i
+        elsif opts[:page]
+          query['num'] = opts[:skip].to_i + (opts[:page].to_i * opts[:per_page].to_i)
+        end
+
+        # allow the use of complex werieis
+        if opts[:query]
+          query['query']         = self.criteria.where(opts[:query]).selector
+        elsif self.criteria.selector != {}
+          query['query']         = self.criteria.selector
+        end
+
+        if opts[:max_distance]
+          query['maxDistance'] = opts[:max_distance].to_f
+          query['maxDistance'] = query['maxDistance']/opts[:unit].to_f if opts[:unit]
+        end
+
+        if opts[:unique_docs]
+            query['uniqueDocs'] = true
+        end
+
+        query['spherical']  = true if opts[:spherical]
+
+        # mongodb < 1.7 returns degrees but with earth flat. in Mongodb 1.7 you can set sphere and let mongodb calculate the distance in Miles or KM
+        # for mongodb < 1.7 we need to run Haversine first before calculating degrees to Km or Miles. See below.
+        query['distanceMultiplier'] = opts[:distance_multiplier].to_f if opts[:distance_multiplier]
+        query
+      end
+    end
+  end
+end

data/lib/mongoid_location/criteria.rb

@@ -0,0 +1,10 @@
+require 'mongoid_location/criterion/complex'
+require 'mongoid_location/criterion/near_spatial'
+require 'mongoid_location/criterion/within_spatial'
+
+
+module Mongoid #:nodoc:
+  class Criteria
+    delegate :geo_near, :to => :context
+  end
+end

data/lib/mongoid_location/criterion/complex.rb

@@ -0,0 +1,25 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+    # Complex criterion are used when performing operations on symbols to get
+    # get a shorthand syntax for where clauses.
+    #
+    # Example:
+    #
+    # <tt>{ :field => { "$lt" => "value" } }</tt>
+    # becomes:
+    # <tt> { :field.lt => "value }</tt>
+    class Complex
+      
+      attr_accessor :key, :operator
+      
+      def initialize(opts = {})
+        @key, @operator = opts[:key], opts[:operator]
+      end
+      
+      def to_mongo_query v
+        {"$#{operator}" => v}
+      end
+    end
+  end
+end

data/lib/mongoid_location/criterion/inclusion.rb

@@ -0,0 +1,14 @@
+# encoding: utf-8
+# module Mongoid #:nodoc:
+#   module Criterion #:nodoc:
+#     module Inclusion
+#       def near(attributes = {})
+#         update_selector(attributes, "$near")
+#       end
+
+#       def near_sphere(attributes = {})
+#         update_selector(attributes, "$near")
+#       end
+#     end
+#   end
+# end

data/lib/mongoid_location/criterion/near_spatial.rb

@@ -0,0 +1,52 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+
+    # NearSpecial criterion is used when performing #near with symbols to get
+    # get a shorthand syntax for where clauses.
+    #
+    # @example Coninputersion of a simple to complex criterion.
+    #   { :field => { "$nearSphere" => [20,30]}, '$maxDistance' => 5 }
+    #   becomes:
+    #   { :field.near_sphere => {:point => [20,30], :max => 5, :unit => :km} }
+    class NearSpatial < Complex
+
+      # Coninputert input to query for near or nearSphere
+      #
+      # @example
+      #   near = NearSpatial.new(:key => :field, :operator => "near")
+      #   near.to_mongo_query({:point => [:50,50], :max => 5, :unit => :km}) => { '$near : [50,50]' , '$maxDistance' : 5 }
+      #
+      # @param [Hash,Array] input input to coninputer to query
+      def to_mongo_query(input)
+        if input.respond_to?(:x)
+          {"$#{operator}" => [input.x, input.y]} #, '$maxDistance' => input[1] }
+        elsif input.kind_of?(Hash)
+          raise ':point required to make valid query' unless input[:point]
+          input[:point] = input[:point].to_xy if input[:point].respond_to?(:to_xy)
+          query = {"$#{operator}" => input[:point] }
+          if input[:max]
+            query['$maxDistance'] = input[:max].to_f
+
+            if unit = Mongoid::Location.earth_radius[input[:unit]]
+              unit *= Mongoid::Location::RAD_PER_DEG unless operator =~ /sphere/i
+              input[:unit] = unit
+            end
+
+            query['$maxDistance'] = query['$maxDistance']/input[:unit].to_f if input[:unit]
+          end
+          query
+        elsif input.kind_of? Array
+          if input.first.kind_of? Numeric
+            {"$#{operator}" => input }
+          else
+            input[0] = input[0].to_xy if input[0].respond_to?(:to_xy)
+            {"$#{operator}" => input[0], '$maxDistance' => input[1] }
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/mongoid_location/criterion/within_spatial.rb

@@ -0,0 +1,62 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Criterion #:nodoc:
+
+    # WithinSpecial criterion is used when performing #within with symbols to get
+    # get a shorthand syntax for where clauses.
+    #
+    # @example Conversion of a simple to complex criterion.
+    #   { :field => { "$within" => {'$center' => [20,30]} } }
+    #   becomes:
+    #   { :field.within(:center) => [20,30] }
+    class WithinSpatial < Complex
+
+      # Convert input to query for box, polygon, center, and centerSphere
+      #
+      # @example
+      #   within = WithinSpatial.new(opts[:key] => 'point', :operator => 'center')
+      #   within.to_mongo_query({:point => [20,30], :max => 5, :unit => :km}) #=>
+      #
+      # @param [Hash,Array] input Variable to conver to query
+      def to_mongo_query(input)
+        if ['box','polygon'].include?(@operator)
+          input = input.values if input.kind_of?(Hash)
+          if input.respond_to?(:map)
+            input.map! do |v|
+              v.respond_to?(:to_xy) ? v.to_xy : v
+            end
+          else
+            input
+          end
+        elsif ['center','centerSphere'].include?(@operator)
+
+          if input.kind_of?(Hash) || input.kind_of?(ActiveSupport::OrderedHash)
+            raise ':point required to make valid query' unless input[:point]
+            input[:point] = input[:point].to_xy if input[:point].respond_to?(:to_xy)
+            if input[:max]
+              input[:max] = input[:max].to_f
+
+              if unit = Mongoid::Location.earth_radius[input[:unit]]
+                unit *= Mongoid::Location::RAD_PER_DEG unless operator =~ /sphere/i
+                input[:unit] = unit
+              end
+
+              input[:max] = input[:max]/input[:unit].to_f if input[:unit]
+
+              input = [input[:point],input[:max]]
+            else
+              input = input[:point]
+            end
+          end
+
+          if input.kind_of? Array
+            input[0] = input[0].to_xy if input[0].respond_to?(:to_xy)
+          end
+
+        end
+        {'$within' => {"$#{@operator}"=>input} }
+      end
+    end
+  end
+end
+

data/lib/mongoid_location/extensions/rgeo_spherical_point_impl.rb

@@ -0,0 +1,13 @@
+module RGeo
+  module Geographic
+    class SphericalPointImpl
+      def to_a
+        [x, y, z]
+      end
+
+      def [] index
+        to_a[index]
+      end
+    end
+  end
+end

data/lib/mongoid_location/extensions/symbol.rb

@@ -0,0 +1,46 @@
+# encoding: utf-8
+module Mongoid #:nodoc:
+  module Extensions #:nodoc:
+    module Symbol #:nodoc:
+
+      # return a class that will accept a value to convert the query correctly for near
+      #
+      # @param [Symbol] calc This accepts :sphere
+      #
+      # @return [Criterion::NearSpatial]
+
+      def near(calc = :flat)
+        Criterion::NearSpatial.new(:operator => get_op('near',calc), :key => self)
+      end
+
+      # alias for self.near(:sphere)
+      #
+      # @return [Criterion::NearSpatial]
+      def near_sphere
+        self.near(:sphere)
+      end
+
+      # @param [Symbol] shape :box,:polygon,:center,:center_sphere
+      #
+      # @return [Criterion::WithinSpatial]
+      def within(shape)
+        shape = get_op(:center,:sphere) if shape == :center_sphere
+        Criterion::WithinSpatial.new(:operator => shape.to_s , :key => self)
+      end
+
+      private
+
+      def get_op operator, calc
+        if calc.to_sym == :sphere
+          "#{operator}Sphere"
+        else
+          operator.to_s
+        end
+      end
+
+    end
+  end
+end
+
+
+::Symbol.__send__(:include, Mongoid::Extensions::Symbol)

data/lib/mongoid_location/field_option.rb

@@ -0,0 +1,16 @@
+#require 'ostruct'
+
+Mongoid::Fields.option :spatial do |model,field,options|
+  options = {} unless options.kind_of?(Hash)
+  lat_meth = options[:lat] || :lat
+  lng_meth = options[:lng] || :lng
+  model.class_eval do
+    self.spatial_fields ||= []
+    self.spatial_fields << field.name.to_sym if self.spatial_fields.kind_of? Array
+
+    define_method "distance_from_#{field.name}" do |*args|
+      self.distance_from(field.name, *args)
+    end
+
+  end
+end

data/lib/mongoid_location/fields/line_string.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Location
+    class LineString
+      # See http://mongoid.org/en/mongoid/docs/upgrading.html
+      def mongoize
+        to_a
+      end
+
+      class << self
+        def demongoize(object)
+          RGeo::Geographic.spherical_factory.line_string *object
+        end
+        # def evolve(object)
+        #   { "$gte" => object.first, "$lte" => object.last }
+        # end
+      end  
+      
+    end
+  end
+end

data/lib/mongoid_location/fields/mongoid2/line_string.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Location
+    class LineString
+      include Mongoid::Fields::Serializable
+
+      def self.instantiate name, options = {}
+        super
+      end
+
+      def serialize(object)
+        object.to_a
+      end
+
+      def deserialize(object)
+        return unless object && !object.empty?
+        RGeo::Geographic.spherical_factory.line_string(*object)
+      end
+    end
+  end
+end

data/lib/mongoid_location/fields/mongoid2/point.rb

@@ -0,0 +1,20 @@
+module Mongoid
+  module Location
+    class Point
+      include Mongoid::Fields::Serializable
+
+      def self.instantiate name, options = {}
+        super
+      end
+
+      def serialize(object)
+        object.respond_to?(:x) ? [object.x, object.y] : object
+      end
+
+      def deserialize(object)
+        return unless object && !object.empty?
+        RGeo::Geographic.spherical_factory.point *object
+      end
+    end
+  end
+end

data/lib/mongoid_location/fields/mongoid2/polygon.rb

@@ -0,0 +1,23 @@
+module Mongoid
+  module Location
+    class Polygon
+      include Mongoid::Fields::Serializable
+
+      def self.instantiate name, options = {}
+        super
+      end
+
+      def serialize(object)
+        object
+      end
+
+      def deserialize(object)
+        points = object.map do |pair|
+          RGeo::Geographic.spherical_factory.point *pair
+        end
+        ring = RGeo::Geographic.spherical_factory.linear_ring points
+        RGeo::Geographic.spherical_factory.polygon ring
+      end
+    end
+  end
+end

data/lib/mongoid_location/fields/point.rb

@@ -0,0 +1,63 @@
+module Mongoid
+  module Location
+    class Point
+      # See http://mongoid.org/en/mongoid/docs/upgrading.html
+
+      def mongoize
+        self.respond_to?(:x) ? [x, y] : self
+        # if object.respond_to? :x
+        #   { "x" => object.x, "y" => object.y }
+        # else
+        #   { "x" => object[0], "y" => object[1] }
+        # end
+      end
+
+      class << self
+
+        def demongoize(object)
+          return unless object && !object.empty?
+          RGeo::Geographic.spherical_factory.point *object
+          #["x"], object["y"]
+        end
+
+        def mongoize(object)
+          object.respond_to?(:x) ? [object.x, object.y] : object
+        end
+
+        # Converts the object that was supplied to a criteria and converts it
+        # into a database friendly form.
+        def evolve(object)
+          object.respond_to?(:x) ? [object.x, object.y] : object
+        end
+      end
+
+# -    self.spacial_fields ||= []
+# -    self.spacial_fields << field.name.to_sym if self.spacial_fields.kind_of? Array
+# -
+# -    define_method "distance_from_#{field.name}" do |*args|
+# -      self.distance_from(field.name, *args)
+# -    end
+# -
+# -    define_method field.name do
+# -      output = self[field.name] || [nil,nil]
+# -      output = {lng_meth => output[0], lat_meth => output[1]} unless options[:return_array]
+# -      return options[:class].new(output) if options[:class]
+# -      output
+# -    end
+# -
+# -    define_method "#{field.name}=" do |arg|
+# -      if arg.kind_of?(Hash) && arg[lng_meth] && arg[lat_meth]
+# -        arg = [arg[lng_meth].to_f, arg[lat_meth].to_f]
+# -      elsif arg.respond_to?(:to_xy)
+# -        arg = arg.to_xy
+# -      end
+# -      self[field.name]=arg
+# -      arg = [nil,nil] if arg.nil?
+# -      return arg[0..1] if options[:return_array]
+# -      h = {lng_meth => arg[0], lat_meth => arg[1]}
+# -      return h if options[:class].blank?
+# -      options[:class].new(h)
+
+    end
+  end
+end

data/lib/mongoid_location/fields/polygon.rb

@@ -0,0 +1,25 @@
+module Mongoid
+  module Location
+    class Polygon
+      # See http://mongoid.org/en/mongoid/docs/upgrading.html
+
+      def mongoize
+        self #.flatten
+      end
+
+      class << self
+        def demongoize(object)
+          points = object.map do |pair|
+            RGeo::Geographic.spherical_factory.point *pair
+          end
+          ring = RGeo::Geographic.spherical_factory.linear_ring points
+          RGeo::Geographic.spherical_factory.polygon ring
+        end
+        # def evolve(object)
+        #   { "$gte" => object.first, "$lte" => object.last }
+        # end
+      end
+      
+    end
+  end
+end

data/lib/mongoid_location/finders.rb

@@ -0,0 +1,5 @@
+module Mongoid #:nodoc:
+  module Finders
+    delegate :geo_near, :to => :criteria 
+  end
+end

data/lib/mongoid_location/location.rb

@@ -0,0 +1,86 @@
+require 'mongoid_location/location/core_ext'
+require 'mongoid_location/location/geo_near_results'
+
+module Mongoid
+  module Location
+    extend ActiveSupport::Concern
+
+    LNG_SYMBOLS = [:x, :lon, :long, :lng, :longitude]
+    LAT_SYMBOLS = [:y, :lat, :latitude]
+
+    EARTH_RADIUS_KM = 6371 # taken directly from mongodb
+
+    EARTH_RADIUS = {
+      :km => EARTH_RADIUS_KM,
+      :m  => EARTH_RADIUS_KM*1000,
+      :mi => EARTH_RADIUS_KM*0.621371192, # taken directly from mongodb
+      :ft => EARTH_RADIUS_KM*5280*0.621371192,
+      :sm => EARTH_RADIUS_KM*0.53995680345572 # sea mile
+    }
+
+    GEO_FACTORY = RGeo::Geographic.spherical_factory
+    RAD_PER_DEG = Math::PI/180
+    mattr_accessor :lng_symbols
+    @@lng_symbols = LNG_SYMBOLS.dup
+
+    mattr_accessor :lat_symbols
+    @@lat_symbols = LAT_SYMBOLS.dup
+
+    mattr_accessor :earth_radius
+    @@earth_radius = EARTH_RADIUS.dup
+
+    mattr_accessor :paginator
+    @@paginator = :array
+
+    mattr_accessor :default_per_page
+    @@default_per_page = 25
+
+    # mattr_accessor :spherical_distance_formula
+    # @@spherical_distance_formula = :n_vector
+    mattr_accessor :geo_factory
+    @@geo_factory = GEO_FACTORY.dup
+
+    included do
+      attr_accessor :geo
+      cattr_accessor :spatial_fields, :spatial_fields_indexed
+      @@spatial_fields = []
+      @@spatial_fields_indexed = []
+    end
+
+    module ClassMethods #:nodoc:
+      # create spatial index for given field
+      # @param [String,Symbol] name
+      # @param [Hash] options options for spatial_index
+
+      def spatial_index name, options = {}
+        self.spatial_fields_indexed << name
+        if Mongoid::VERSION =~ /3.0/
+          index({name => '2d'}, options)
+        else
+          index [[name, '2d']], options
+        end
+      end
+    end
+
+    # def distance(p2, opts = {})
+    #   p1 = self.send(key)
+    #   Mongoid::Location.distance(p1, p2, opts)
+    # end
+
+    # def self.distance(p1,p2,opts = {})
+    #   opts[:formula] ||= (opts[:spherical]) ? @@spherical_distance_formula : :pythagorean_theorem
+    #   p1 = p1.to_lng_lat if p1.respond_to?(:to_lng_lat)
+    #   p2 = p2.to_lng_lat if p2.respond_to?(:to_lng_lat)
+
+    #   rads = Formulas.send(opts[:formula], p1, p2)
+
+    #   if unit = earth_radius[opts[:unit]]
+    #     opts[:unit] = (rads.instance_variable_get("@radian")) ? unit : unit * RAD_PER_DEG
+    #   end
+
+    #   rads *= opts[:unit].to_f if opts[:unit]
+    #   rads
+    # end
+
+  end
+end

data/lib/mongoid_location/location/core_ext.rb

@@ -0,0 +1,29 @@
+class Array
+  def to_xy
+    self[0..1].map(&:to_f)
+  end
+  alias :to_lng_lat :to_xy
+end
+
+class Hash
+  def to_xy
+    raise "Hash must have at least 2 items" if self.size < 2
+    [to_x, to_y]
+  end
+  alias :to_lng_lat :to_xy
+
+  def to_y
+    v = (Mongoid::Location.lat_symbols & self.keys).first
+    return self[v].to_f if !v.nil? && self[v]
+    raise "Hash must contain #{Mongoid::Location.lat_symbols.inspect} if ruby version is less than 1.9" if RUBY_VERSION.to_f < 1.9
+    raise "Hash cannot contain #{Mongoid::Location.lng_symbols.inspect} as the second item if there is no #{Mongoid::Location.lat_symbols.inspect}" if Mongoid::Location.lng_symbols.index(self.keys[1])
+    self.values[1].to_f
+  end
+
+  def to_x
+    v = (Mongoid::Location.lng_symbols & self.keys).first
+    return self[v].to_f if !v.nil? && self[v]
+    raise "Hash cannot contain #{Mongoid::Location.lat_symbols.inspect} as the first item if there is no #{Mongoid::Location.lng_symbols.inspect}" if Mongoid::Location.lat_symbols.index(self.keys[0])
+    self.values[0].to_f
+  end
+end

data/lib/mongoid_location/location/geo_near_results.rb

@@ -0,0 +1,140 @@
+module Mongoid
+  module Location
+    class GeoNearResults < Array
+      attr_reader :stats, :document, :_original_array, :_original_opts
+      attr_accessor :opts
+
+      def initialize(document,results,opts = {})
+        raise "#{document.name} class must include Mongoid::Location::Document" unless document.respond_to?(:spatial_fields_indexed)
+        @document = document
+        @opts = opts
+        @_original_opts = opts.clone
+        @stats = results['stats'] || {}
+        @opts[:skip] ||= 0
+
+        @_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.spatial_fields_indexed if @document.spatial_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.spatial_fields_indexed.kind_of?(Array) && @document.spatial_fields_indexed.size == 1
+              primary = @document.spatial_fields_indexed.first
+            end
+            @opts[:calculate].each do |key|
+              res.geo[(key.to_s+'_distance').to_sym] = res.distance_from(key,center,{:unit =>@opts[:unit] || @opts[:distance_multiplier], :spherical => @opts[:spherical]} )
+              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.
+          @_paginated_array = @_original_array.clone
+          super(@_paginated_array[@opts[:skip]+start, @opts[:per_page]] || [])
+        else
+          super(@_original_array[@opts[:skip]..-1] || [])
+        end
+      end
+
+      def page(*args)
+        new_collection = self.clone
+        new_collection.page!(*args)
+        new_collection
+      end
+
+      def page!(page, options = {})
+        original = options.delete(:original)
+        self.opts.merge!(options)
+        self.opts[:paginator] ||= Mongoid::Location.paginator
+        self.opts[:page] = page
+        start = (self.current_page-1)*self.limit_value # assuming current_page is 1 based.
+
+        if original
+          @_paginated_array = @_original_array.clone
+          self.replace(@_paginated_array[self.opts[:skip]+start, self.limit_value] || [])
+        else
+          @_paginated_array ||= self.to_a
+          self.replace(@_paginated_array[self.opts[:skip]+start, self.limit_value])
+        end
+        true
+      end
+
+      def per(num)
+        self.page(current_page, :per_page => num)
+      end
+
+      def reset!
+        self.replace(@_original_array)
+        @opts = @_original_opts
+        @_paginated_array = nil
+        true
+      end
+
+      def reset
+        clone = self.clone
+        clone.reset!
+        clone
+      end
+
+      def total_entries
+        (@_paginated_array) ? @_paginated_array.count : @_original_array.count
+      end
+      alias_method :total_count, :total_entries
+
+      def current_page
+        page = (@opts[:page]) ? @opts[:page].to_i.abs : 1
+        (page < 1) ? 1 : page
+      end
+
+      def limit_value
+        if @opts[:per_page]
+          @opts[:per_page] = @opts[:per_page].to_i.abs
+        else
+          @opts[:per_page] = case self.opts[:paginator]
+                             when :will_paginate
+                               @document.per_page
+                             when :kaminari
+                               Kaminari.config.default_per_page
+                             else
+                               Mongoid::Location.default_per_page
+                             end
+        end
+      end
+      alias_method :per_page, :limit_value
+
+      def num_pages
+        (total_entries && @opts[:per_page]) ? (total_entries.to_f / @opts[:per_page]).ceil : nil
+      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_location/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module Location
-    VERSION = "0.3.1"
+    VERSION = "0.3.2"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mongoid_location
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.3.2
   prerelease: 
 platform: ruby
 authors:
@@ -153,6 +153,26 @@ files:
 - README.md
 - Rakefile
 - lib/mongoid_location.rb
+- lib/mongoid_location/contexts/mongo.rb
+- lib/mongoid_location/contextual/mongo.rb
+- lib/mongoid_location/criteria.rb
+- lib/mongoid_location/criterion/complex.rb
+- lib/mongoid_location/criterion/inclusion.rb
+- lib/mongoid_location/criterion/near_spatial.rb
+- lib/mongoid_location/criterion/within_spatial.rb
+- lib/mongoid_location/extensions/rgeo_spherical_point_impl.rb
+- lib/mongoid_location/extensions/symbol.rb
+- lib/mongoid_location/field_option.rb
+- lib/mongoid_location/fields/line_string.rb
+- lib/mongoid_location/fields/mongoid2/line_string.rb
+- lib/mongoid_location/fields/mongoid2/point.rb
+- lib/mongoid_location/fields/mongoid2/polygon.rb
+- lib/mongoid_location/fields/point.rb
+- lib/mongoid_location/fields/polygon.rb
+- lib/mongoid_location/finders.rb
+- lib/mongoid_location/location.rb
+- lib/mongoid_location/location/core_ext.rb
+- lib/mongoid_location/location/geo_near_results.rb
 - lib/mongoid_location/version.rb
 - mongoid_location.gemspec
 homepage: http://www.openxid.com