mongoid-geospatial 3.9.0

data/spec/mongoid/geospatial/fields/point_spec.rb

@@ -0,0 +1,254 @@
+require 'spec_helper'
+
+describe Mongoid::Geospatial::Point do
+
+  it 'should not interfer with mongoid' do
+    Bar.create!(name: "Moe's")
+    expect(Bar.count).to eql(1)
+  end
+
+  it 'should not fail if point is nil' do
+    bar = Bar.create!(name: "Moe's")
+    expect(bar.location).to be_nil
+  end
+
+  it 'should set point methodically' do
+    bar = Bar.create!(name: "Moe's", location: Mongoid::Geospatial::Point.new)
+    bar.location = Mongoid::Geospatial::Point.new(8, 8)
+    expect(bar.save).to be_truthy
+    expect(Bar.first.location.x).to eq(8)
+  end
+
+  it 'should set point with comma separated text' do
+    bar = Bar.create!(name: "Moe's", location: Mongoid::Geospatial::Point.new)
+    bar.location = '2.99,3.99'
+    expect(bar.location.mongoize).to eq([2.99, 3.99])
+  end
+
+  it 'should set point with space separated text' do
+    bar = Bar.create!(name: "Moe's", location: Mongoid::Geospatial::Point.new)
+    bar.location = '2.99 3.99'
+    expect(bar.location.mongoize).to eq([2.99, 3.99])
+  end
+
+  it 'should set point with space comma separated text' do
+    bar = Bar.create!(name: "Moe's", location: Mongoid::Geospatial::Point.new)
+    bar.location = '2.99 ,  3.99'
+    expect(bar.location.mongoize).to eq([2.99, 3.99])
+  end
+
+  it 'should set point to nil' do
+    bar = Bar.create!(name: "Moe's", location: [1, 1])
+    bar.location = nil
+    expect(bar.location).to be_nil
+    expect(bar.save).to be_truthy
+    expect(Bar.where(location: nil).first).to eq(bar)
+  end
+
+  it 'should set point empty string to nil' do
+    bar = Bar.create!(name: "Moe's", location: [1, 1])
+    bar.location = ''
+    expect(bar.location).to be_nil
+    expect(bar.save).to be_truthy
+    expect(Bar.where(location: nil).first).to eq(bar)
+  end
+
+  it 'should set point empty array to nil' do
+    bar = Bar.create!(name: "Moe's", location: [1, 1])
+    bar.location = []
+    expect(bar.location).to be_nil
+    expect(bar.save).to be_truthy
+    expect(Bar.where(location: nil).first).to eq(bar)
+  end
+
+  describe 'methods' do
+
+    let(:bar) { Bar.create!(location: [3, 2]) }
+
+    it 'should have a .to_a' do
+      expect(bar.location.to_a[0..1]).to eq([3.0, 2.0])
+    end
+
+    it 'should have an array [] accessor' do
+      expect(bar.location[0]).to eq(3.0)
+    end
+
+    it 'should have an ActiveModel symbol accessor' do
+      expect(bar[:location]).to eq([3, 2])
+    end
+
+    it 'should have a radius helper' do
+      expect(bar.location.radius).to eql([[3.0, 2.0], 1])
+    end
+
+    it 'should have a radius sphere helper' do
+      expect(bar.location.radius_sphere[1]).to be_within(0.0001).of(0.00015)
+    end
+
+    it 'should have a radius sphere helper in meters' do
+      expect(bar.location.radius_sphere(1000, :m)[1]).to be_within(0.0001).of(0.00015)
+    end
+
+    it 'should have a radius sphere helper in miles' do
+      expect(bar.location.radius_sphere(1, :mi)[1]).to be_within(0.0001).of(0.00025)
+    end
+
+  end
+
+  describe 'queryable' do
+
+    before do
+      Bar.create_indexes
+    end
+
+    describe ':near :near_sphere' do
+
+      let!(:berlin) do
+        Bar.create(name: :berlin, location: [52.30, 13.25])
+      end
+
+      let!(:prague) do
+        Bar.create(name: :prague, location: [50.5, 14.26])
+      end
+
+      let!(:paris) do
+        Bar.create(name: :paris, location: [48.48, 2.20])
+      end
+
+      let!(:jim) do
+        Person.new(location: [41.23, 2.9])
+      end
+
+      it 'returns the documents sorted closest to furthest' do
+        expect(Bar.where(:location.near => jim.location))
+          .to eq([paris, prague, berlin])
+      end
+
+      it 'returns the documents sorted closest to furthest' do
+        expect(Bar.near(location: jim.location))
+          .to eq([paris, prague, berlin])
+      end
+
+      it 'returns the documents sorted closest to furthest sphere' do
+        person = Person.new(location: [41.23, 2.9])
+        expect(Bar.near_sphere(location: jim.location))
+          .to eq([paris, prague, berlin])
+      end
+
+      it 'returns the documents sorted closest to furthest sphere' do
+        person = Person.new(location: [41.23, 2.9])
+        expect(Bar.where(:location.near_sphere => jim.location))
+          .to eq([paris, prague, berlin])
+      end
+
+      it 'returns the documents sorted closest to furthest with max' do
+        expect(Bar.near(location: jim.location).max_distance(location: 10).to_a)
+          .to eq([paris]) # , prague, berlin ]
+      end
+
+    end
+
+    describe ':within_circle :within_spherical_circle' do
+      let!(:mile1) do
+        Bar.create(name: 'mile1', location: [-73.997345, 40.759382])
+      end
+
+      let!(:mile3) do
+        Bar.create(name: 'mile3', location: [-73.927088, 40.752151])
+      end
+
+      let!(:mile7) do
+        Bar.create(name: 'mile7', location: [-74.0954913, 40.7161472])
+      end
+
+      let!(:mile9) do
+        Bar.create(name: 'mile9', location: [-74.0604951, 40.9178011])
+      end
+
+      let!(:elvis) do
+        Person.new(location: [-73.98, 40.75])
+      end
+
+      it 'returns the documents within a center_circle' do
+        expect(Bar.where(:location.within_circle =>
+                         [elvis.location, 250.0 /
+                           Mongoid::Geospatial::EARTH_RADIUS_KM]).to_a)
+          .to eq([mile1])
+      end
+
+      it 'returns the documents within a center_circle' do
+        expect(Bar.where(:location.within_circle => [elvis.location,
+                           500.0 / Mongoid::Geospatial::EARTH_RADIUS_KM])
+                 .to_a).to include(mile3)
+      end
+
+      it 'returns the documents within a center_sphere' do
+        expect(Bar.where(:location.within_spherical_circle =>
+                         [elvis.location, 0.0005]).to_a).to eq([mile1])
+      end
+
+      it 'returns the documents within a center_sphere' do
+        expect(Bar.where(:location.within_spherical_circle =>
+                         [elvis.location, 0.5]).to_a).to include(mile9)
+      end
+
+      it 'returns the documents within a box' do
+        expect(Bar.within_box(location: [elvis.location,
+                                elvis.location.map(&:ceil)]).to_a)
+          .to eq([mile3])
+      end
+
+    end
+
+  end
+
+  describe '(de)mongoize' do
+
+    it 'should mongoize array' do
+      bar = Bar.new(location: [10, -9])
+      expect(bar.location.class).to eql(Mongoid::Geospatial::Point)
+      expect(bar.location.x).to be_within(0.1).of(10)
+      expect(bar.location.y).to be_within(0.1).of(-9)
+    end
+
+    it 'should mongoize hash' do
+      geom = Bar.new(location: { x: 10, y: -9 }).location
+      expect(geom.class).to eql(Mongoid::Geospatial::Point)
+      expect(geom.x).to be_within(0.1).of(10)
+      expect(geom.y).to be_within(0.1).of(-9)
+    end
+
+    it 'should mongoize hash with symbols in any order' do
+      geom = Bar.new(location: { y: -9, x: 10 }).location
+      expect(geom.class).to eql(Mongoid::Geospatial::Point)
+      expect(geom.x).to be_within(0.1).of(10)
+      expect(geom.y).to be_within(0.1).of(-9)
+    end
+
+    it 'should mongoize hash with string keys in any order' do
+      geom = Bar.new(location: { 'y' => -9, 'x' => 10 }).location
+      expect(geom.class).to eql(Mongoid::Geospatial::Point)
+      expect(geom.x).to be_within(0.1).of(10)
+      expect(geom.y).to be_within(0.1).of(-9)
+    end
+
+    # should raise
+    # geom.to_geo
+
+    describe 'with rgeo' do
+
+      describe 'instantiated' do
+
+        let(:bar) { Bar.create!(name: 'Vitinho', location: [10, 10]) }
+
+        it 'should demongoize to rgeo' do
+          expect(bar.location.class).to eql(Mongoid::Geospatial::Point)
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/spec/mongoid/geospatial/fields/polygon_spec.rb

@@ -0,0 +1,84 @@
+require 'spec_helper'
+
+describe Mongoid::Geospatial::Polygon do
+
+  describe '(de)mongoize' do
+
+    it 'should support a field mapped as polygon' do
+      farm = Farm.new(area: [[5, 5], [6, 5], [6, 6], [5, 6]])
+      expect(farm.area).to be_a Mongoid::Geospatial::Polygon
+      expect(farm.area).to eq([[5, 5], [6, 5], [6, 6], [5, 6]])
+    end
+
+    it 'should store as array on mongo' do
+      Farm.create(area: [[5, 5], [6, 5], [6, 6], [5, 6]])
+      expect(Farm.first.area).to eq([[5, 5], [6, 5], [6, 6], [5, 6]])
+    end
+
+    it 'should have a bounding box' do
+      geom = Mongoid::Geospatial::Polygon.new [[1, 5], [6, 5], [6, 6], [5, 6]]
+      expect(geom.bbox).to eq([[1, 5], [6, 6]])
+    end
+
+    it 'should have a center point' do
+      geom = Mongoid::Geospatial::Polygon.new [[1, 1], [1, 1], [9, 9], [9, 9]]
+      expect(geom.center).to eq([5.0, 5.0])
+    end
+
+    it 'should have a radius helper' do
+      geom = Mongoid::Geospatial::Polygon.new [[1, 1], [1, 1], [9, 9], [9, 9]]
+      expect(geom.radius(10)).to eq([[5.0, 5.0], 10])
+    end
+
+    it 'should have a radius sphere' do
+      geom = Mongoid::Geospatial::Polygon.new [[1, 1], [1, 1], [9, 9], [9, 9]]
+      expect(geom.radius_sphere(10)[1]).to be_within(0.001).of(0.001569)
+    end
+
+    describe 'with rgeo' do
+      # farm.area.should be_a RGeo::Geographic::SphericalPolygonImpl
+    end
+
+  end
+
+  describe 'query' do
+
+    context ':box, :polygon' do
+
+      before do
+        Farm.create_indexes
+      end
+
+      let!(:ranch) do
+        Farm.create(name: 'Ranch', area: [[1, 1], [3, 3]], geom: [2, 2])
+      end
+
+      let!(:farm) do
+        Farm.create(name: 'Farm', area: [[47, 1], [49, 1.5], [49, 3], [46, 5]], geom: [47.5, 2.26])
+      end
+
+      it 'returns the documents within a box' do
+        expect(Farm.where(:geom.within_polygon =>
+                          ranch.area).to_a).to eq([ranch])
+      end
+
+      it 'returns the documents within a polygon' do
+        expect(Farm.where(:geom.within_polygon =>
+                          farm.area).to_a).to eq([farm])
+      end
+
+      it 'returns the documents within a center' do
+        expect(Farm.where(:geom.within_circle =>
+                          [ranch.geom, 0.4]).first).to eq(ranch)
+      end
+
+      it 'returns the documents within a center_sphere' do
+        expect(Farm.where(:geom.within_spherical_circle =>
+                          [ranch.geom, 0.1]).first).to eq(ranch)
+      end
+
+    end
+
+  end
+
+end

data/spec/mongoid/geospatial/geospatial_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+describe Mongoid::Geospatial do
+
+  context 'Class Stuff' do
+
+    it 'should have an lng_symbols accessor' do
+      expect(Mongoid::Geospatial.lng_symbols).to be_instance_of Array
+      expect(Mongoid::Geospatial.lng_symbols).to include :x
+    end
+
+    it 'should have an lat_symbols accessor' do
+      expect(Mongoid::Geospatial.lat_symbols).to be_instance_of Array
+      expect(Mongoid::Geospatial.lat_symbols).to include :y
+    end
+
+  end
+
+  context 'Creating indexes' do
+
+    it 'should create a 2d index' do
+      Bar.create_indexes
+      expect(Bar.collection.indexes[location: '2d']).not_to be_nil
+    end
+
+    it 'should create a 2dsphere index' do
+      Alarm.create_indexes
+      expect(Alarm.collection.indexes[spot: '2dsphere']).not_to be_nil
+    end
+
+  end
+
+  context '#nearby 2d' do
+
+    before do
+      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
+      expect(Bar.nearby(lax.location)).to eq([lax, jfk])
+    end
+
+  end
+
+  context '#nearby 2dsphere' do
+
+    before do
+      Alarm.create_indexes
+    end
+
+    let!(:jfk) do
+      Alarm.create(name: 'jfk', spot: [-73.77694444, 40.63861111])
+    end
+
+    let!(:lax) do
+      Alarm.create(name: 'lax', spot: [-118.40, 33.94])
+    end
+
+    it 'should work with specifying specific center and different spot attribute on collction' do
+      expect(Alarm.nearby(lax.spot)).to eq([lax, jfk])
+    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
+
+    #   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
+    #         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 ':paginate' do
+    #   before do
+    #     Bar.create_indexes
+    #     50.times do
+    #       Bar.create({:location => [rand(360)-180,rand(360)-180]})
+    #     end
+    #   end
+
+    #   [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
+
+end