mongoid-geospatial 4.0.1 → 5.0.0

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

@@ -15,29 +15,65 @@ describe Mongoid::Geospatial::LineString do
       expect(River.first.course).to eq(river.course)
     end
 
+    it 'should line_string += point nicely' do
+      river = River.create!(name: 'Amazonas', course: [[1, 1], [9, 9]])
+      river.course += [[10, 10]]
+      river.save
+      expect(River.first.course).to eq([[1, 1], [9, 9], [10, 10]])
+    end
+
+    it 'should parent.line_string << point nicely' do
+      pending 'Mongoid Issue #...'
+      river = River.create!(name: 'Amazonas', course: [[1, 1], [9, 9]])
+      river.course.push [10, 10]
+      river.save
+      expect(River.first.course).to eq([[1, 1], [9, 9], [10, 10]])
+    end
+
+    it 'should have same obj id' do
+      pending 'Mongoid Issue #...'
+      river = River.create!(name: 'Amazonas', course: [[1, 1], [9, 9]])
+      expect(river.course.object_id).to eq(river.course.object_id)
+    end
+
+    it 'should have same obj id ary' do
+      river = River.create!(name: 'Amazonas', mouth_array: [[1, 1], [9, 9]])
+      expect(river.mouth_array.object_id).to eq(river.mouth_array.object_id)
+    end
+
     it 'should support a field mapped as linestring' do
       River.create!(course: [[5, 5], [6, 5], [6, 6], [5, 6]])
       expect(River.first.course).to eq([[5, 5], [6, 5], [6, 6], [5, 6]])
     end
 
     it 'should have a bounding box' do
-      geom = Mongoid::Geospatial::LineString.new [[1, 5], [6, 5], [6, 6], [5, 6]]
-      expect(geom.bbox).to eq([[1, 5], [6, 6]])
+      l = Mongoid::Geospatial::LineString.new [[1, 5], [6, 5], [6, 6], [5, 6]]
+      expect(l.bbox).to eq([[1, 5], [6, 6]])
+    end
+
+    it 'should have a geom box' do
+      l = Mongoid::Geospatial::LineString.new [[1, 1], [5, 5]]
+      expect(l.geom_box).to eq([[1, 1], [1, 5], [5, 5], [5, 1], [1, 1]])
+    end
+
+    it 'should have a geom box' do
+      l = Mongoid::Geospatial::LineString.new [[1, 1], [2, 2], [3, 4], [5, 5]]
+      expect(l.geom_box).to eq([[1, 1], [1, 5], [5, 5], [5, 1], [1, 1]])
     end
 
     it 'should have a center point' do
-      geom = Mongoid::Geospatial::LineString.new [[1, 1], [1, 1], [9, 9], [9, 9]]
-      expect(geom.center).to eq([5.0, 5.0])
+      l = Mongoid::Geospatial::LineString.new [[1, 1], [1, 1], [9, 9], [9, 9]]
+      expect(l.center).to eq([5.0, 5.0])
     end
 
     it 'should have a radius helper' do
-      geom = Mongoid::Geospatial::LineString.new [[1, 1], [1, 1], [9, 9], [9, 9]]
-      expect(geom.radius(10)).to eq([[5.0, 5.0], 10])
+      l = Mongoid::Geospatial::LineString.new [[1, 1], [1, 1], [9, 9], [9, 9]]
+      expect(l.radius(10)).to eq([[5.0, 5.0], 10])
     end
 
     it 'should have a radius sphere' do
-      geom = Mongoid::Geospatial::LineString.new [[1, 1], [1, 1], [9, 9], [9, 9]]
-      expect(geom.radius_sphere(10)[1]).to be_within(0.001).of(0.001569)
+      l = Mongoid::Geospatial::LineString.new [[1, 1], [1, 1], [9, 9], [9, 9]]
+      expect(l.radius_sphere(10)[1]).to be_within(0.001).of(0.001569)
     end
   end
 end

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

@@ -13,9 +13,10 @@ describe Mongoid::Geospatial::Point do
     end
 
     it 'should set point methodically' do
-      bar.location = Mongoid::Geospatial::Point.new(8, 8)
+      bar.location = Mongoid::Geospatial::Point.new(8, 9)
       expect(bar.save).to be_truthy
       expect(Bar.first.location.x).to eq(8)
+      expect(Bar.first.location.y).to eq(9)
     end
 
     it 'should set point with comma separated text' do
@@ -34,6 +35,11 @@ describe Mongoid::Geospatial::Point do
     end
   end
 
+  it 'should have #reverse to get lat, lon' do
+    bar = Bar.create!(name: "Moe's", location: [1, 2])
+    expect(bar.location.reverse).to eq([2, 1])
+  end
+
   it 'should set point to nil' do
     bar = Bar.create!(name: "Moe's", location: [1, 1])
     bar.location = nil
@@ -42,6 +48,13 @@ describe Mongoid::Geospatial::Point do
     expect(Bar.where(location: nil).first).to eq(bar)
   end
 
+  it 'should update point x' do
+    bar = Bar.create!(name: "Moe's", location: [1, 1])
+    bar.location = [2, 3]
+    expect(bar.save).to be_truthy
+    expect(Bar.first.location.to_a).to eq([2, 3])
+  end
+
   it 'should set point empty string to nil' do
     bar = Bar.create!(name: "Moe's", location: [1, 1])
     bar.location = ''
@@ -78,15 +91,18 @@ describe Mongoid::Geospatial::Point do
     end
 
     it 'should have a radius sphere helper' do
-      expect(bar.location.radius_sphere[1]).to be_within(0.0001).of(0.00015)
+      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)
+      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)
+      expect(bar.location.radius_sphere(1, :mi)[1])
+        .to be_within(0.0001).of(0.00025)
     end
   end
 
@@ -162,43 +178,29 @@ describe Mongoid::Geospatial::Point do
       end
 
       it 'returns the documents within a circle' do
-        pending 'Moped'
-        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 circle' do
-        pending 'Moped'
-        expect(Bar.where(:location.within_circle => [elvis.location,
-                                                     500.0 / Mongoid::Geospatial::EARTH_RADIUS_KM])
-                 .to_a).to include(mile3)
+        pending 'Circle'
+        l = [elvis.location, 500.0 / Mongoid::Geospatial::EARTH_RADIUS_KM]
+        expect(Bar.where(:location.within_circle => l).to_a).to include(mile3)
       end
 
       it 'returns the documents within a spherical circle' do
-        pending 'Moped'
+        pending 'Circle'
         expect(Bar.where(:location.within_spherical_circle =>
                          [elvis.location, 0.0005]).to_a).to eq([mile1])
       end
 
-      it 'returns the documents within a spherical circle 2' do
-        pending 'Moped'
-        expect(Bar.where(:location.within_spherical_circle =>
-                         [elvis.location, 0.5]).to_a).to include(mile9)
-      end
-
       it 'returns the documents within a center circle' do
-        pending 'Moped'
+        pending 'Circle'
         expect(Bar.where(:location.within_center_circle =>
                          [elvis.location, 0.0005]).to_a).to eq([mile1])
       end
 
       it 'returns the documents within a box' do
-        pending 'Moped'
-        expect(Bar.within_box(location: [elvis.location,
-                                         elvis.location.map(&:ceil)]).to_a)
-          .to eq([mile3])
+        poly = Mongoid::Geospatial::LineString.new(
+          [elvis.location.map { |c| c + 1 },
+           elvis.location.map { |c| c - 1 }])
+        expect(Bar.where(:location.within_polygon => [poly.geom_box]).to_a)
+          .to include(mile3)
       end
     end
   end

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

@@ -1,6 +1,11 @@
 require 'spec_helper'
 
 describe Mongoid::Geospatial::Polygon do
+  it 'should have correct indexes on farm' do
+    Farm.create_indexes
+    expect(Farm.collection.indexes.get(geom: '2dsphere')).not_to be_nil
+  end
+
   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]])
@@ -45,36 +50,38 @@ describe Mongoid::Geospatial::Polygon do
       end
 
       let!(:ranch) do
-        Farm.create(name: 'Ranch', area: [[1, 1], [3, 3]], geom: [2, 2])
+        Farm.create!(name: 'Ranch',
+                     area: [[1, 1], [3, 3], [3, 1], [1, 1]],
+                     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])
+        Farm.create!(name: 'Farm',
+                     area: [[47, 1], [48, 1.5], [49, 3], [49, 1], [47, 1]],
+                     geom: [48, 1.28])
       end
 
       it 'returns the documents within a box' do
-        pending 'Moped'
-        expect(Farm.where(:geom.within_polygon =>
-                          ranch.area).to_a).to eq([ranch])
+        query = Farm.geo_spacial(:geom.within_polygon => [ranch.area])
+        expect(query.to_a).to eq([ranch])
       end
 
       it 'returns the documents within a polygon' do
-        pending 'Moped'
-        expect(Farm.where(:geom.within_polygon =>
-                          farm.area).to_a).to eq([farm])
+        query = Farm.where(:geom.within_polygon => [farm.area])
+        expect(query.to_a).to eq([farm])
       end
 
-      it 'returns the documents within a center' do
-        pending 'Moped'
-        expect(Farm.where(:geom.within_circle =>
-                          [ranch.geom, 0.4]).first).to eq(ranch)
-      end
+      # it 'returns the documents within a center' do
+      #   pending 'Moped'
+      #   expect(Farm.where(:geom.within_circle =>
+      #                     [ranch.geom, 0.4]).first).to eq(ranch)
+      # end
 
-      it 'returns the documents within a center_sphere' do
-        pending 'Moped'
-        expect(Farm.where(:geom.within_spherical_circle =>
-                          [ranch.geom, 0.1]).first).to eq(ranch)
-      end
+      # it 'returns the documents within a center_sphere' do
+      #   pending 'Moped'
+      #   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

@@ -16,12 +16,12 @@ describe Mongoid::Geospatial do
   context 'Creating indexes' do
     it 'should create a 2d index' do
       Bar.create_indexes
-      expect(Bar.collection.indexes[location: '2d']).not_to be_nil
+      expect(Bar.collection.indexes.get(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
+      expect(Alarm.collection.indexes.get(spot: '2dsphere')).not_to be_nil
     end
   end
 
@@ -56,79 +56,95 @@ describe Mongoid::Geospatial 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
+    it 'should work with specific center and different spot attribute' 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
+    it 'should work with default origin' do
+      expect(Alarm.near_sphere(spot: lax.spot)).to eq([lax, jfk])
+    end
 
-    #   end
+    it 'should work with default origin key' do
+      expect(Alarm.where(:spot.near_sphere => lax.spot)).to eq([lax, jfk])
+    end
+
+    context ':paginate' do
+      before do
+        Alarm.create_indexes
+        50.times do
+          Alarm.create(spot: [rand(10) + 1, rand(10) + 1])
+        end
+      end
+
+      it 'limits fine with 25' do
+        expect(Alarm.near_sphere(spot: [5, 5])
+                .limit(25).to_a.size).to eq 25
+      end
+
+      it 'limits fine with 25 and skips' do
+        expect(Alarm.near_sphere(spot: [5, 5])
+                .skip(25).limit(25).to_a.size).to eq 25
+      end
+
+      it 'paginates 50' do
+        page1 = Alarm.near_sphere(spot: [5, 5]).limit(25)
+        page2 = Alarm.near_sphere(spot: [5, 5]).skip(25).limit(25)
+        expect((page1 + page2).uniq.size).to eq(50)
+      end
+    end
+
+    context ':query' do
+      before do
+        Alarm.create_indexes
+        3.times do
+          Alarm.create(spot: [jfk.spot.x + rand(0), jfk.spot.y + rand(0)])
+        end
+      end
+
+      it 'should filter using extra query option' do
+        query = Alarm.near_sphere(spot: jfk.spot).where(name: jfk.name)
+        expect(query.to_a).to eq [jfk]
+      end
+    end
+
+    context ':maxDistance' do
+      it 'should get 1 item' do
+        spot = 2465 / Mongoid::Geospatial.earth_radius[:mi]
+        query = Alarm.near_sphere(spot: lax.spot).max_distance(spot: spot)
+        expect(query.to_a.size).to eq 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)
+    #         Bar.geo_near(lax.location,
+    #         ::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)
+    #         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
+    #         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
+    #       Bar.any_of({:name => jfk.name},{:name => lax.name})
+    #         .geo_near(jfk.location).should == [jfk,lax]
     #     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

data/spec/mongoid/geospatial/helpers/core_spec.rb

@@ -12,15 +12,20 @@ module Mongoid
     def self.from_hash_y(hsh)
       v = (Mongoid::Geospatial.lat_symbols & hsh.keys).first
       return hsh[v].to_f if !v.nil? && hsh[v]
-      fail "Hash must contain #{Mongoid::Geospatial.lat_symbols.inspect} if ruby version is less than 1.9" if RUBY_VERSION.to_f < 1.9
-      fail "Hash cannot contain #{Mongoid::Geospatial.lng_symbols.inspect} as the second item if there is no #{Mongoid::Geospatial.lat_symbols.inspect}" if Mongoid::Geospatial.lng_symbols.index(hsh.keys[1])
+      if Mongoid::Geospatial.lng_symbols.index(hsh.keys[1])
+        fail "Hash cannot contain #{Mongoid::Geospatial.lng_symbols.inspect} "\
+             "as second arg without #{Mongoid::Geospatial.lat_symbols.inspect}"
+      end
       hsh.values[1].to_f
     end
 
     def self.from_hash_x(hsh)
       v = (Mongoid::Geospatial.lng_symbols & hsh.keys).first
       return hsh[v].to_f if !v.nil? && hsh[v]
-      fail "Hash cannot contain #{Mongoid::Geospatial.lat_symbols.inspect} as the first item if there is no #{Mongoid::Geospatial.lng_symbols.inspect}" if Mongoid::Geospatial.lat_symbols.index(keys[0])
+      if Mongoid::Geospatial.lat_symbols.index(keys[0])
+        fail "Hash cannot contain #{Mongoid::Geospatial.lat_symbols.inspect} "\
+             "as first arg without #{Mongoid::Geospatial.lng_symbols.inspect}"
+      end
       values[0].to_f
     end
   end

data/spec/mongoid/geospatial/helpers/delegate_spec.rb

@@ -44,7 +44,24 @@ describe Mongoid::Fields do
 
     it 'should not work fine with nils' do
       bus = Bus.create!(name: 'B', location: nil)
-      expect { bus.x = 9; bus.y = 9 }.to raise_error(NoMethodError)
+      expect do
+        bus.x = 9
+        bus.y = 9
+      end.to raise_error(NoMethodError)
+    end
+
+    it 'should update point x' do
+      bus = Bus.create!(name: '0789', location: [1, 1])
+      bus.x = 2
+      expect(bus.save).to be_truthy
+      expect(Bus.first.location.to_a).to eq([2, 1])
+    end
+
+    it 'should update point y' do
+      bus = Bus.create!(name: '0987', location: [1, 1])
+      bus.y = 2
+      expect(bus.save).to be_truthy
+      expect(Bus.first.location.to_a).to eq([1.0, 2.0])
     end
   end
 end