mongoid-geospatial 3.9.0

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

@@ -0,0 +1,27 @@
+module Mongoid
+  module Geospatial
+    def self.from_array(ary)
+      ary[0..1].map(&:to_f)
+    end
+
+    def self.from_hash(hsh)
+      fail '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]
+      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])
+      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])
+      values[0].to_f
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+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 = 9; bus.y = 9
+      expect(bus.location.to_a).to eq([9, 9])
+    end
+
+    it 'should work fine with default values' do
+      event = Event.create!(name: 'Bvent')
+      event.x = 9; event.y = 9
+      expect(event.location.to_a).to eq([9, 9])
+    end
+
+    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)
+    end
+
+  end
+
+end

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

@@ -0,0 +1,36 @@
+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[location: '2d']).not_to be_nil
+    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

@@ -0,0 +1,26 @@
+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[spot: '2dsphere']).not_to be_nil
+    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

@@ -0,0 +1,66 @@
+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

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+describe 'RGeo Wrapper' do
+
+  before(:all) do
+    # Mongoid::Geospatial.send(:remove_const, 'Point')
+    # Mongoid::Geospatial.send(:remove_const, 'Polygon')
+    # Mongoid::Geospatial.send(:remove_const, 'Line')
+
+    # load "#{File.dirname(__FILE__)}/../../../lib/mongoid/geospatial/fields/point.rb"
+    # load "#{File.dirname(__FILE__)}/../../../lib/mongoid/geospatial/fields/polygon.rb"
+    # load "#{File.dirname(__FILE__)}/../../../lib/mongoid/geospatial/fields/line.rb"
+
+    # Object.send(:remove_const, 'Bar')
+    # load "#{File.dirname(__FILE__)}/../../models/bar.rb"
+
+    # Object.send(:remove_const, 'Farm')
+    # load "#{File.dirname(__FILE__)}/../../models/farm.rb"
+
+    # Object.send(:remove_const, 'River')
+    # load "#{File.dirname(__FILE__)}/../../models/river.rb"
+  end
+
+  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 not respond to to_geo before loading external' do
+      farm = Farm.create!(area: [[5, 5], [6, 5], [6, 6], [5, 6]])
+      expect(farm.area).not_to respond_to(:to_geo)
+    end
+  end
+
+  describe Mongoid::Geospatial::Line do
+    it 'should not interfer with mongoid' do
+      River.create!(name: 'Mississippi')
+      expect(River.count).to eql(1)
+    end
+
+    it 'should not respond to to_geo before loading external' do
+      river = River.create!(course: [[5, 5], [6, 5], [6, 6], [5, 6]])
+      expect(river.course).not_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.to_rgeo.class).to eql(RGeo::Geographic::SphericalPointImpl)
+          expect(geom.x).to be_within(0.1).of(10)
+          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, :spherical => true)
+          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::Line 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::Line)
+          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

data/spec/spec_helper.rb

@@ -0,0 +1,64 @@
+# require 'pry'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+
+MODELS = File.join(File.dirname(__FILE__), 'models')
+SUPPORT = File.join(File.dirname(__FILE__), 'support')
+$LOAD_PATH.unshift(MODELS)
+$LOAD_PATH.unshift(SUPPORT)
+
+if ENV['CI']
+  # require "simplecov"
+  require 'coveralls'
+  Coveralls.wear!
+  # SimpleCov.formatter = Coveralls::SimpleCov::Formatter
+  # SimpleCov.start do
+  #  add_filter "spec"
+  # end
+end
+
+require 'mongoid'
+# require "mocha"
+require 'rspec'
+require 'mongoid/geospatial'
+
+# These environment variables can be set if wanting to test against a database
+# that is not on the local machine.
+ENV['MONGOID_SPEC_HOST'] ||= 'localhost'
+ENV['MONGOID_SPEC_PORT'] ||= '27018'
+
+# These are used when creating any connection in the test suite.
+HOST = ENV['MONGOID_SPEC_HOST']
+PORT = ENV['MONGOID_SPEC_PORT'].to_i
+
+LOGGER = Logger.new($stdout)
+
+if RUBY_VERSION >= '1.9.2'
+  YAML::ENGINE.yamler = 'syck'
+end
+
+puts "Running with Mongoid v#{Mongoid::VERSION}"
+
+Mongoid.configure do |config|
+  config.connect_to('mongoid_geo_test')
+end
+
+# Autoload every model for the test suite that sits in spec/app/models.
+Dir[File.join(MODELS, '*.rb')].sort.each do |file|
+  name = File.basename(file, '.rb')
+  autoload name.camelize.to_sym, name
+end
+
+Dir[File.join(SUPPORT, '*.rb')].each { |file| require File.basename(file) }
+
+def bson_object_id_class
+  Moped::BSON::ObjectId
+end
+
+RSpec.configure do |config|
+  # config.mock_with(:mocha)
+
+  config.before(:each) do
+    Mongoid.purge!
+  end
+end

data/spec/support/authentication.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+module Support #:nodoc:
+  # module Authentication
+  #   extend self
+
+  #   def configured?
+  #     begin
+  #       master_uri = "mongodb://mongoid:test@localhost:27017/mongoid_geospatial_test"
+  #       Mongo::Connection.from_uri(master_uri)
+  #       true
+  #     rescue Mongo::AuthenticationError => e
+  #       false
+  #     end
+  #   end
+
+  #   def message
+  #     %Q{
+  #     ---------------------------------------------------------------------
+  #     A user needs to be configured for authentication, otherwise some
+  #     configuration specs will not get run. You may set it up from the
+  #     mongo console:
+
+  #       $ use mongoid_geospatial_test;
+  #       $ db.addUser("mongoid", "test");
+  #     ---------------------------------------------------------------------
+  #     }
+  #   end
+  # end
+end

data/spec/support/mongod.conf

@@ -0,0 +1,3 @@
+dbpath = /usr/local/var/mongodb
+master = true
+bind_ip = 127.0.0.1

data/spec/support/mongoid.yml

@@ -0,0 +1,19 @@
+test:
+  database: mongoid_geospatial_test
+  host: localhost
+  port: 27018
+  slaves:
+    # - host: localhost
+      # port: 27018
+    # - host: localhost
+      # port: 27019
+  # allow_dynamic_fields: false
+  # include_root_in_json: true
+  # parameterize_keys: false
+  # persist_in_safe_mode: false
+  # raise_not_found_error: false
+  # reconnect_time: 5
+  # autocreate_indexes: false
+  # persist_types: false
+  # option_no_exist: false
+  # skip_version_check: false