mongoid_geospatial 2.0.0 → 2.2.0

data/lib/mongoid_geospatial/criterion/near_spatial.rb

@@ -1,52 +0,0 @@
-# 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::Geospatial.earth_radius[input[:unit]]
-              unit *= Mongoid::Geospatial::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_geospatial/criterion/within_spatial.rb

@@ -1,62 +0,0 @@
-# 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::Geospatial.earth_radius[input[:unit]]
-                unit *= Mongoid::Geospatial::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_geospatial/extensions/symbol.rb

@@ -1,46 +0,0 @@
-# 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_geospatial/finders.rb

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

data/lib/mongoid_geospatial/geospatial/geo_near_results.rb

@@ -1,140 +0,0 @@
-module Mongoid
-  module Geospatial
-    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::Geospatial::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::Geospatial.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::Geospatial.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/spec/mongoid_geospatial/contextual/mongo_spec.rb

@@ -1,135 +0,0 @@
-require "spec_helper"
-
-describe (Mongoid::VERSION > '3' ? Mongoid::Contextual::Mongo :  Mongoid::Contexts::Mongo) do
-  describe "#geo_near" do
-
-    before do
-      Bar.delete_all
-      Bar.create_indexes
-    end
-
-    let!(:jfk) do
-      Bar.create(:name => 'jfk', :location => [-73.77694444, 40.63861111 ])
-    end
-
-    let!(:lax) do
-      Bar.create(:name => 'lax', :location => [-118.40, 33.94])
-    end
-
-    it "should work with specifying specific center and different location attribute on collction" do
-      Bar.geo_near(lax.location, :spherical => true).should == [lax, jfk]
-      Bar.geo_near(jfk.location, :spherical => true).should == [jfk, lax]
-    end
-    context 'option' do
-      context ':num' do
-        it "should limit number of results to 1" do
-          Bar.geo_near(jfk.location, :num => 1).size.should == 1
-        end
-      end
-
-      context ':maxDistance' do
-        it "should get 1 item" do
-          Bar.geo_near(lax.location, :spherical => true, :max_distance => 2465/Mongoid::Geospatial.earth_radius[:mi]).size.should == 1
-        end
-        it "should get 2 items" do
-          Bar.geo_near(lax.location, :spherical => true, :max_distance => 2480/Mongoid::Geospatial.earth_radius[:mi]).size.should == 2
-        end
-
-      end
-
-      context ':distance_multiplier' do
-        it "should multiply returned distance with multiplier" do
-          Bar.geo_near(lax.location, :spherical => true, :distance_multiplier=> Mongoid::Geospatial.earth_radius[:mi]).second.geo[:distance].to_i.should be_within(1).of(2469)
-        end
-      end
-
-      context ':unit' do
-        it "should multiply returned distance with multiplier" do
-          pending
-          Bar.geo_near(lax.location, :spherical => true, :unit => :mi).second.geo[:distance].to_i.should be_within(1).of(2469)
-        end
-
-        it "should convert max_distance to radians with unit" do
-          Bar.geo_near(lax.location, :spherical => true, :max_distance => 2465, :unit => :mi).size.should == 1
-        end
-
-      end
-
-      context ':query' do
-        it "should filter using extra query option" do
-          # two record in the collection, only one's name is Munich
-          Bar.geo_near(jfk.location, :query => {:name => jfk.name}).should == [jfk]
-        end
-      end
-
-    end
-
-    context 'criteria chaining' do
-      it "should filter by where" do
-        Bar.where(:name => jfk.name).geo_near(jfk.location).should == [jfk]
-        Bar.any_of({:name => jfk.name},{:name => lax.name}).geo_near(jfk.location).should == [jfk,lax]
-      end
-
-      it 'should skip 1' do
-        Bar.skip(1).geo_near(jfk.location).size.should == 1
-      end
-
-      it 'should limit 1' do
-        Bar.limit(1).geo_near(jfk.location).size.should == 1
-      end
-    end
-  end
-
-  context ':page' do
-    before do
-      Bar.delete_all
-      Bar.create_indexes
-
-      50.times do
-        Bar.create({:location => [rand(360)-180,rand(360)-180]})
-      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 => 20).size.should == 0
-      end
-
-      it "per_page=5" 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 50 Bars' do
-        Bar.all.count.should == 50
-      end
-
-      it "should have limit_value" do
-        near.limit_value.should == 25
-      end
-
-      # check results['results'] in GeoNearResults
-      it 'should find 25 items' do 
-        near.size.should == 25
-      end
-
-      it "should have current_page" do
-        near.current_page.should == 1
-      end
-
-      it "should have num_pages" do
-        near.num_pages.should == 1
-      end
-    end
-  end
-
-end