mongoid-geospatial 7.0.0 → 7.1.0

data/spec/models/place.rb

@@ -1,13 +0,0 @@
-# Sample spec class
-class Place
-  include Mongoid::Document
-  include Mongoid::Geospatial
-
-  field :name,     type: String
-  field :location, type: Point, spatial: true
-
-  has_one :rating, as: :ratable
-
-  spatial_index :location
-  spatial_scope :location
-end

data/spec/models/river.rb

@@ -1,22 +0,0 @@
-# Sample spec class
-class River
-  include Mongoid::Document
-  include Mongoid::Geospatial
-
-  field :name,        type: String
-  field :length,      type: Integer
-  field :discharge,   type: Integer
-  field :course,      type: LineString,   spatial: true
-  # set return_array to true if you do not want a hash returned all the time
-  field :source,      type: Point,        spatial: true
-  field :mouth,       type: Point,        spatial: { lat: 'latitude', lng: 'longitude' }
-  field :mouth_array, type: Array,        spatial: { return_array: true }
-
-  # simplified spatial indexing
-  # you can only index one field in mongodb < 1.9
-  spatial_index :source
-  # alternatives
-  # index [[ :spatial, Mongo::GEO2D ]], {min:-400, max:400}
-  # index [[ :spatial, Mongo::GEO2D ]], {bit:32}
-  # index [[ :spatial, Mongo::GEO2D ],:name]
-end

data/spec/mongoid/geospatial/config_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe Mongoid::Geospatial::Config do
-  context 'point' do
-    it 'uses LonLat by default' do
-      expect(Mongoid::Geospatial.config.point.x).to eq Mongoid::Geospatial.lng_symbols
-      expect(Mongoid::Geospatial.config.point.y).to eq Mongoid::Geospatial.lat_symbols
-    end
-    context 'configured as latlon' do
-      before do
-        Mongoid::Geospatial.configure do |config|
-          config.point.x = Mongoid::Geospatial.lat_symbols
-          config.point.y = Mongoid::Geospatial.lng_symbols
-        end
-      end
-      it 'uses latlon' do
-        expect(Mongoid::Geospatial.config.point.x).to eq Mongoid::Geospatial.lat_symbols
-        expect(Mongoid::Geospatial.config.point.y).to eq Mongoid::Geospatial.lng_symbols
-      end
-    end
-  end
-end

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

@@ -1,8 +0,0 @@
-require 'spec_helper'
-
-describe Mongoid::Geospatial::Box do
-  it 'should work' do
-    alarm = Alarm.new(area: [[1, 2], [3, 4]])
-    expect(alarm.area).to be_a Mongoid::Geospatial::Box
-  end
-end

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

@@ -1,8 +0,0 @@
-require 'spec_helper'
-
-describe Mongoid::Geospatial::Circle do
-  it 'should work' do
-    alarm = Alarm.new(radius: [[1, 2], 3])
-    expect(alarm.radius).to be_a Mongoid::Geospatial::Circle
-  end
-end

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

@@ -1,78 +0,0 @@
-require 'spec_helper'
-
-describe Mongoid::Geospatial::LineString do
-  describe '(de)mongoize' do
-    it 'should support a field mapped as linestring' do
-      river = River.new(course: [[5, 5], [6, 5], [6, 6], [5, 6]])
-      expect(river.course).to be_a Mongoid::Geospatial::LineString
-      expect(river.course).to eq([[5, 5], [6, 5], [6, 6], [5, 6]])
-    end
-
-    it 'should update line string too' do
-      river = River.create!(name: 'Amazonas')
-      river.course = [[1, 1], [1, 1], [9, 9], [9, 9]]
-      river.save
-      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 NOT parent.line_string << point nicely (mongoid doesnt track <<)' 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]])
-    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
-      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
-      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
-      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
-      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

@@ -1,296 +0,0 @@
-require 'spec_helper'
-
-describe Mongoid::Geospatial::Point do
-  describe "Moe's Bar" do
-    let(:bar) { Bar.create!(name: "Moe's") }
-
-    it 'should not interfer with mongoid' do
-      expect(bar.class.count).to eql(1)
-    end
-
-    it 'should not fail if point is nil' do
-      expect(bar.location).to be_nil
-    end
-
-    it 'should set point methodically' do
-      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
-      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.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.location = '2.99 ,  3.99'
-      expect(bar.location.mongoize).to eq([2.99, 3.99])
-    end
-
-    it 'should set point from hash' do
-      bar.location = { latitude: 2.99, longitude: 3.99 }
-      expect(bar.location.mongoize).to eq([3.99, 2.99])
-    end
-
-    context 'configured as latlon' do
-      before do
-        Mongoid::Geospatial.configure do |config|
-          config.point.x = Mongoid::Geospatial.lat_symbols
-          config.point.y = Mongoid::Geospatial.lng_symbols
-        end
-      end
-      it 'should set point from hash' do
-        bar.location = { latitude: 2.99, longitude: 3.99 }
-        expect(bar.location.mongoize).to eq([2.99, 3.99])
-      end
-    end
-  end
-
-  it "should have a to_s method" do
-    bar = Bar.create!(name: "Moe's", location: [1, 2])
-    expect(bar.location.to_s).to eq('1.0, 2.0')
-  end
-
-  it "should have a to_s method" do
-    bar = Bar.create!(name: "Moe's", location: [1.0009, 21.009])
-    expect(bar.location.to_s).to eq('1.0009, 21.009')
-  end
-
-  it "should have a to_geo_json method" do
-    bar = Bar.create!(name: "Moe's", location: [1.0009, 21.009])
-    expect(bar.location.to_geo_json).to eq({
-      type: "Point", coordinates: [1.0009, 21.009]
-    })
-  end
-
-  it "should have a to_json method" do
-    bar = Bar.create!(name: "Moe's", location: [1.0009, 21.009])
-    expect(bar.location.to_json).to eq("[1.0009,21.009]")
-  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
-    expect(bar.location).to be_nil
-    expect(bar.save).to be_truthy
-    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 = ''
-    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_a).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.closest_to_location(jim.location).to_a)
-          .to eq([paris, prague, berlin])
-      end
-
-      it 'returns the documents sorted closest to furthest' do
-        expect(Bar.where(:location.near => jim.location).to_a)
-          .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: person.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 => person.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 circle' do
-        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 'Circle'
-        expect(Bar.where(:location.within_spherical_circle =>
-                         [elvis.location, 0.0005]).to_a).to eq([mile1])
-      end
-
-      it 'returns the documents within a center circle' do
-        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
-        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
-
-  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.new(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

@@ -1,87 +0,0 @@
-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]])
-      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], [3, 1], [1, 1]],
-                     geom: [2, 2])
-      end
-
-      let(:farm) do
-        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
-        query = Farm.geo_spatial(:geom.within_polygon => [ranch.area])
-        expect(query.to_a).to eq([ranch])
-      end
-
-      it 'returns the documents within a polygon' do
-        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_sphere' do
-      #   pending 'Moped'
-      #   expect(Farm.where(:geom.within_spherical_circle =>
-      #                     [ranch.geom, 0.1]).first).to eq(ranch)
-      # end
-    end
-  end
-end