mongoid-geospatial 7.0.0 → 7.1.0

data/spec/mongoid/geospatial/geospatial_spec.rb

@@ -1,222 +0,0 @@
-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.get(location: '2d')).not_to be_nil
-    end
-
-    it 'should create a 2dsphere index' do
-      Alarm.create_indexes
-      expect(Alarm.collection.indexes.get(spot: '2dsphere')).not_to be_nil
-    end
-  end
-
-  context '#nearby 2d' do
-    before do
-      Bar.create_indexes
-    end
-    after do
-      Bar.collection.indexes.drop_all
-    end
-
-    let!(:moes) do
-      Bar.create!(name: "Moe's", location: [-73.77694444, 40.63861111])
-    end
-
-    let!(:rose) do
-      Bar.create!(name: 'Rosa', location: [-118.40, 33.94])
-    end
-
-    let!(:jane) do
-      Bar.create!(name: "Jane's", location: [1, 1])
-    end
-
-    let!(:foo) do
-      Bar.create!(name: "Foo", location: [3, 3])
-    end
-
-    it 'should work specifing center and different location foo' do
-      expect(Bar.nearby(foo.location)).to be_a Mongoid::Criteria
-      expect(Bar.nearby(foo.location).selector).to eq({"location" => {"$near" => [3.0, 3.0]}})
-    end
-
-    it 'should work specifing center and different location moes' do
-      expect(Bar.nearby(moes.location).limit(2)).to eq([moes, rose])
-    end
-
-    it 'should work finding first' do
-      expect(Bar.nearby(moes.location).first).to eq(moes)
-    end
-
-    it 'really should work find first nearby' do
-      expect(Bar.count).to eq(4)
-      expect(Bar.nearby([1, 1]).to_a).to eq([jane, foo, moes, rose])
-      expect(Bar.nearby([2, 2]).to_a.first).to eq(jane)
-      # THIS WILL FAIL MONGOID ISSUE
-      # expect(Bar.nearby(rose.location).first).to eq(rose)
-    end
-
-    it 'should work specifing first' do
-      bars = Bar.nearby(rose.location).to_a
-      expect(bars.first).to eq(rose)
-    end
-
-    it 'should work specifing first' do
-      expect(Bar.nearby(rose.location).to_a.first).to eq(rose)
-    end
-
-    it 'should work specifing first' do
-      expect(Bar.nearby(rose.location).to_a.first).to eq(rose)
-    end
-
-    it 'should work specifing first' do
-      expect(Bar.nearby(rose.location).first).to eq(rose)
-    end
-
-    it 'returns the documents sorted closest to furthest' do
-      expect(Bar.closest_to_location(rose.location).to_a)
-        .to eq([rose, moes, jane, foo])
-    end
-
-    it 'returns the documents sorted closest to furthest' do
-      expect(Bar.closest_to_location(rose.location).limit(2))
-        .to eq([rose, moes])
-    end
-
-    it 'returns the documents sorted closest to furthest' do
-      expect(Bar.closest_to_location(rose.location).first).to eq(rose)
-    end
-
-    it 'returns the documents sorted closest to furthest' do
-      expect(Bar.closest_to_location(rose.location).to_a)
-        .to eq([rose, moes, jane, foo])
-    end
-
-    it 'should work specifing center and different location foo' do
-      expect(Bar.closest_to_location(foo.location)).to be_a Mongoid::Criteria
-      expect(Bar.closest_to_location(foo.location).selector).to eq({"location" => {"$near" => [3.0, 3.0]}})
-    end
-
-  end
-
-  context '#nearby 2dsphere' do
-    before do
-      Alarm.create_indexes
-    end
-    after do
-      Alarm.collection.indexes.drop_all
-    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 specific center and different spot attribute' do
-      expect(Alarm.nearby(lax.spot)).to eq([lax, jfk])
-    end
-
-    it 'should work with default origin' do
-      expect(Alarm.near_sphere(spot: lax.spot)).to eq([lax, jfk])
-    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(1..10), rand(1..10)])
-        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,
-    #         ::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
-
-    #   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
-    #   end
-    # end
-  end
-end

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

@@ -1,35 +0,0 @@
-module Mongoid
-  module Geospatial
-    def self.from_array(ary)
-      ary[0..1].map(&:to_f)
-    end
-
-    def self.from_hash(hsh)
-      raise 'Hash must have at least 2 items' if hsh.size < 2
-
-      [from_hash_x(hsh), from_hash_y(hsh)]
-    end
-
-    def self.from_hash_y(hsh)
-      v = (Mongoid::Geospatial.lat_symbols & hsh.keys).first
-      return hsh[v].to_f if !v.nil? && hsh[v]
-
-      if Mongoid::Geospatial.lng_symbols.index(hsh.keys[1])
-        raise "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]
-
-      if Mongoid::Geospatial.lat_symbols.index(keys[0])
-        raise "Hash cannot contain #{Mongoid::Geospatial.lat_symbols.inspect} "\
-             "as first arg without #{Mongoid::Geospatial.lng_symbols.inspect}"
-      end
-      values[0].to_f
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-require 'spec_helper'
-
-describe Mongoid::Fields do
-  context 'delegate' do
-    before do
-      Bus.create_indexes
-    end
-
-    context 'x, y helpers' do
-      let(:bus) { Bus.create!(name: 'Far', location: [7, 8]) }
-
-      it 'should set instance method x' do
-        expect(bus.x).to eq(7)
-      end
-
-      it 'should set instance method y' do
-        expect(bus.y).to eq(8)
-      end
-
-      it 'should set instance method x=' do
-        bus.x = 9
-        expect(bus.x).to eq(9)
-      end
-
-      it 'should set instance method y=' do
-        bus.y = 9
-        expect(bus.y).to eq(9)
-      end
-    end
-
-    it 'should set instance methods x= and y=' do
-      bus = Bus.create!(name: 'B', location: [7, 7])
-      bus.x = 8
-      bus.y = 9
-      expect(bus.location.to_a).to eq([8, 9])
-    end
-
-    it 'should work fine with default values' do
-      event = Event.create!(name: 'Bvent')
-      event.x = 8
-      event.y = 9
-      expect(event.location.to_a).to eq([8, 9])
-    end
-
-    it 'should not work fine with nils' do
-      bus = Bus.create!(name: 'B', location: nil)
-      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

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

@@ -1,40 +0,0 @@
-require 'spec_helper'
-
-describe Mongoid::Fields do
-  context 'spatial' do
-    before do
-      Bar.create_indexes
-    end
-
-    it 'should created indexes' do
-      expect(Bar.collection.indexes.get(location: '2d')).not_to be_nil
-    end
-
-    it 'should create correct indexes' do
-      expect(Bar.collection.indexes.get(location: '2d'))
-        .to eq('background' => false,
-               'key' => { 'location' => '2d' },
-               'name' => 'location_2d',
-               'v' => 2)
-    end
-
-    it 'should set spatial fields' do
-      expect(Bar.spatial_fields).to eql([:location])
-    end
-
-    it 'should set some class methods' do
-      far  = Bar.create!(name: 'Far', location: [7, 7])
-      near = Bar.create!(name: 'Near', location: [2, 2])
-      expect(Bar.nearby([1, 1])).to eq([near, far])
-    end
-
-    # it "should set some class methods" do
-    #   far  = Bar.create!(name: "Far", location: [7,7])
-    #   near = Bar.create!(name: "Near", location: [2,2])
-    #   Bar.near_location([1,1]).should eq([near, far])
-    # end
-  end
-
-  context 'geom' do
-  end
-end

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

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe Mongoid::Fields do
-  context 'spatial' do
-    before do
-      Alarm.create_indexes
-    end
-
-    it 'should created indexes' do
-      expect(Alarm.collection.indexes.get(spot: '2dsphere')).not_to be_nil
-    end
-
-    it 'should create correct indexes' do
-      expect(Alarm.collection.indexes.get(spot: '2dsphere'))
-        .to include('2dsphereIndexVersion' => 3,
-                    'background' => false,
-                    'key' => { 'spot' => '2dsphere' },
-                    'name' => 'spot_2dsphere',
-                    'v' => 2)
-    end
-
-    it 'should set spatial fields' do
-      expect(Alarm.spatial_fields).to eql([:spot])
-    end
-
-    it 'should work fine indexed' do
-      far = Alarm.create!(name: 'Far', spot: [7, 7])
-      expect(far.spot).to be_instance_of(Mongoid::Geospatial::Point)
-    end
-  end
-end

data/spec/mongoid/geospatial/wrappers/georuby_spec.rb

@@ -1,63 +0,0 @@
-require 'spec_helper'
-
-describe Mongoid::Geospatial::Point do
-  it 'should not interfer with mongoid' do
-    Place.create!(name: "Moe's")
-    expect(Place.count).to eql(1)
-  end
-
-  it 'should not respond to distance before loading external gem' do
-    bar = Place.create!(location: [5, 5])
-    expect(bar.location).not_to respond_to(:distance)
-  end
-
-  describe 'queryable' do
-    before do
-      Mongoid::Geospatial.with_georuby!
-      Place.create_indexes
-    end
-
-    describe '(de)mongoize' do
-      it 'should mongoize array' do
-        geom = Place.new(location: [10, -9]).location
-        expect(geom.class).to eql(Mongoid::Geospatial::Point)
-        expect(geom.to_geo.class).to eql(GeoRuby::SimpleFeatures::Point)
-        expect(geom.x).to be_within(0.1).of(10)
-        expect(geom.to_geo.y).to be_within(0.1).of(-9)
-      end
-
-      it 'should mongoize hash' do
-        geom = Place.new(location: { x: 10, y: -9 }).location
-        expect(geom.class).to eql(Mongoid::Geospatial::Point)
-        expect(geom.to_geo.class).to eql(GeoRuby::SimpleFeatures::Point)
-      end
-
-      it 'should accept a GeoRuby point' do
-        point = GeoRuby::SimpleFeatures::Point.from_x_y 1, 2
-        bar = Place.create!(location: point)
-        expect(bar.location.x).to be_within(0.1).of(1)
-        expect(bar.location.y).to be_within(0.1).of(2)
-      end
-
-      it 'should calculate 3d distances by default' do
-        bar = Place.create! location: [-73.77694444, 40.63861111]
-        bar2 = Place.create! location: [-118.40, 33.94] # ,:unit=>:mi, :spherical => true)
-        expect(bar.location.geo_distance(bar2.location).to_i).to be_within(1).of(3_973_808)
-      end
-
-      describe 'simple features' do
-        it 'should mongoize lines' do
-          river = River.new(course: [[1, 2], [3, 4], [5, 6]])
-          expect(river.course.to_geo)
-            .to be_instance_of(GeoRuby::SimpleFeatures::LineString)
-        end
-
-        it 'should mongoize polygon' do
-          farm = Farm.new(area: [[1, 2], [3, 4], [5, 6]])
-          expect(farm.area.to_geo)
-            .to be_instance_of(GeoRuby::SimpleFeatures::Polygon)
-        end
-      end
-    end
-  end
-end

data/spec/mongoid/geospatial/wrappers/rgeo_spec.rb

@@ -1,115 +0,0 @@
-require 'spec_helper'
-
-describe 'RGeo Wrapper' do
-  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 respond to distance before loading external' do
-      bar = Bar.create!(location: [5, 5])
-      expect(bar.location).not_to respond_to(:distance)
-    end
-  end
-
-  describe Mongoid::Geospatial::Polygon do
-    it 'should not interfer with mongoid' do
-      Farm.create!(name: 'Springfield Nuclear Power Plant')
-      expect(Farm.count).to eql(1)
-    end
-
-    it 'should respond to to_geo' do
-      farm = Farm.create!(area: [[5, 5], [6, 5], [6, 6], [5, 6]])
-      expect(farm.area).to respond_to(:to_geo)
-    end
-  end
-
-  describe Mongoid::Geospatial::LineString do
-    it 'should not interfer with mongoid' do
-      River.create!(name: 'Mississippi')
-      expect(River.count).to eql(1)
-    end
-
-    it 'should respond to to_geo before loading external' do
-      river = River.create!(course: [[5, 5], [6, 5], [6, 6], [5, 6]])
-      expect(river.course).to respond_to(:to_geo)
-    end
-  end
-
-  describe 'queryable' do
-    before do
-      Mongoid::Geospatial.with_rgeo!
-      Bar.create_indexes
-      Farm.create_indexes
-      River.create_indexes
-    end
-
-    describe '(de)mongoize' do
-      describe Mongoid::Geospatial::Point do
-        it 'should mongoize array' do
-          geom = Bar.new(location: [10, -9]).location
-          expect(geom.class).to eql(Mongoid::Geospatial::Point)
-          expect(geom.x).to be_within(0.1).of(10)
-        end
-
-        it 'should wrap to georuby' do
-          geom = Bar.new(location: [10, -9]).location
-          expect(geom.to_geo.class)
-            .to eql(GeoRuby::SimpleFeatures::Point)
-          expect(geom.to_geo.y).to be_within(0.1).of(-9)
-        end
-
-        it 'should wrap to rgeo' do
-          geom = Bar.new(location: [10, -9]).location
-          expect(geom.to_rgeo.class)
-            .to eql(RGeo::Geographic::SphericalPointImpl)
-          expect(geom.to_rgeo.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.to_rgeo.class)
-            .to eql(RGeo::Geographic::SphericalPointImpl)
-        end
-
-        it 'should accept an RGeo object' do
-          point = RGeo::Geographic.spherical_factory.point 1, 2
-          bar = Bar.create!(location: point)
-          expect(bar.location.x).to be_within(0.1).of(1)
-          expect(bar.location.y).to be_within(0.1).of(2)
-        end
-
-        it 'should calculate 3d distances by default' do
-          bar = Bar.create! location: [-73.77694444, 40.63861111]
-          bar2 = Bar.create! location: [-118.40, 33.94] # ,:unit=>:mi
-          expect(bar.location.rgeo_distance(bar2.location).to_i)
-            .to be_within(1).of(3_978_262)
-        end
-      end
-
-      describe Mongoid::Geospatial::Polygon do
-        it 'should mongoize array' do
-          geom = Farm.create!(area: [[5, 5], [6, 5], [6, 6], [5, 6]]).area
-          expect(geom.class).to eql(Mongoid::Geospatial::Polygon)
-          expect(geom.to_rgeo.class)
-            .to eql(RGeo::Geographic::SphericalPolygonImpl)
-          expect(geom.to_rgeo.to_s)
-            .to eq 'POLYGON ((5.0 5.0, 6.0 5.0, 6.0 6.0, 5.0 6.0, 5.0 5.0))'
-        end
-      end
-
-      describe Mongoid::Geospatial::LineString do
-        it 'should mongoize array' do
-          geom = River.create!(course: [[5, 5], [6, 5], [6, 6], [5, 6]]).course
-          expect(geom.class).to eql(Mongoid::Geospatial::LineString)
-          expect(geom.to_rgeo.class)
-            .to eql(RGeo::Geographic::SphericalLineStringImpl)
-          expect(geom.to_rgeo.to_s)
-            .to eq 'LINESTRING (5.0 5.0, 6.0 5.0, 6.0 6.0, 5.0 6.0)'
-        end
-      end
-    end
-  end
-end