mongoid_geospatial 1.0.0 → 2.0.0

data/spec/{functional/contexts → mongoid_geospatial/contextual}/mongo_spec.rb

@@ -1,6 +1,6 @@
 require "spec_helper"
 
-describe Mongoid::Contexts::Mongo do
+describe (Mongoid::VERSION > '3' ? Mongoid::Contextual::Mongo :  Mongoid::Contexts::Mongo) do
   describe "#geo_near" do
 
     before do
@@ -77,9 +77,7 @@ describe Mongoid::Contexts::Mongo do
       it 'should limit 1' do
         Bar.limit(1).geo_near(jfk.location).size.should == 1
       end
-
     end
-
   end
 
   context ':page' do
@@ -110,17 +108,27 @@ describe Mongoid::Contexts::Mongo do
 
     context ":paginator :kaminari" do
       let(:near) {Bar.geo_near([1,1], :page => 1)}
-      it "should have current_page" do
-        near.current_page.should == 1
-      end
 
-      it "should have num_pages" do
-        near.num_pages.should == 2
+      it 'should have 50 Bars' do
+        Bar.all.count.should == 50
       end
 
       it "should have limit_value" do
         near.limit_value.should == 25
       end
+
+      # check results['results'] in GeoNearResults
+      it 'should find 25 items' do 
+        near.size.should == 25
+      end
+
+      it "should have current_page" do
+        near.current_page.should == 1
+      end
+
+      it "should have num_pages" do
+        near.num_pages.should == 1
+      end
     end
   end
 

data/spec/mongoid_geospatial/criterion/inclusion_spec.rb

@@ -0,0 +1,375 @@
+require "spec_helper"
+
+# describe "Mongoid::Criterion::Inclusion" do
+describe Mongoid::Criteria do
+
+  before do
+    Person.delete_all
+  end
+
+  describe "#where" do
+
+    let(:dob) do
+      33.years.ago.to_date
+    end
+
+    let(:lunch_time) do
+      30.minutes.ago
+    end
+
+    let!(:person) do
+      Person.create(
+        :title => "Sir",
+        :dob => dob,
+        :lunch_time => lunch_time,
+        :age => 33,
+        :aliases => [ "D", "Durran" ],
+        :things => [ { :phone => 'HTC Incredible' } ]
+      )
+    end
+
+    context "when providing 24 character strings" do
+
+      context "when the field is not an id field" do
+
+        let(:string) do
+          bson_object_id_class.new.to_s
+        end
+
+        let!(:person) do
+          Person.create(:title => string)
+        end
+
+        let(:from_db) do
+          Person.where(:title => string)
+        end
+
+        it "does not convert the field to a bson id" do
+          from_db.should == [ person ]
+        end
+      end
+    end
+
+    context "when providing string object ids" do
+
+      context "when providing a single id" do
+
+        let(:from_db) do
+          Person.where(:_id => person.id.to_s).first
+        end
+
+        it "returns the matching documents" do
+          from_db.should == person
+        end
+      end
+    end
+
+    context "chaining multiple wheres" do
+
+      context "when chaining on the same key" do
+
+        let(:from_db) do
+          Person.where(:title => "Maam").where(:title => "Sir")
+        end
+
+        it "overrides the previous key" do
+          from_db.should == [ person ]
+        end
+      end
+
+      context "with different criteria on the same key" do
+
+        it "merges criteria" do
+          Person.where(:age.gt => 30).where(:age.lt => 40).should == [person]
+        end
+
+        it "typecasts criteria" do
+          before_dob = (dob - 1.month).to_s
+          after_dob = (dob + 1.month).to_s
+          Person.where(:dob.gt => before_dob).and(:dob.lt => after_dob).should == [person]
+        end
+
+      end
+    end
+
+    context "with untyped criteria" do
+
+      it "typecasts integers" do
+        pending "seems typecasts not work fo mongoid 3.0" if Mongoid::VERSION > '3'
+        Person.where(:age => "33").should == [ person ]
+      end
+
+      it "typecasts datetimes" do
+        pending "seems typecasts not work fo mongoid 3.0" if Mongoid::VERSION > '3'
+        Person.where(:lunch_time => lunch_time.to_s).should == [ person ]
+      end
+
+      it "typecasts dates" do
+        pending "seems typecasts not work fo mongoid 3.0" if Mongoid::VERSION > '3'
+        Person.where({:dob => dob.to_s}).should == [ person ]
+      end
+
+      it "typecasts times with zones" do
+        pending "seems typecasts not work fo mongoid 3.0" if Mongoid::VERSION > '3'
+        time = lunch_time.in_time_zone("Alaska")
+        Person.where(:lunch_time => time).should == [ person ]
+      end
+
+      it "typecasts array elements" do
+        pending "seems typecasts not work fo mongoid 3.0" if Mongoid::VERSION > '3'
+        Person.where(:age.in => [17, "33"]).should == [ person ]
+      end
+
+      it "typecasts size criterion to integer" do
+        pending "seems typecasts not work fo mongoid 3.0" if Mongoid::VERSION > '3'
+        Person.where(:aliases.size => "2").should == [ person ]
+      end
+
+      it "typecasts exists criterion to boolean" do
+        pending "seems typecasts not work fo mongoid 3.0" if Mongoid::VERSION > '3'
+        Person.where(:score.exists => "f").should == [ person ]
+      end
+    end
+
+    context "with multiple complex criteria" do
+
+      before do
+        Person.create(:title => "Mrs", :age => 29)
+        Person.create(:title => "Ms", :age => 41)
+      end
+
+      it "returns those matching both criteria" do
+        Person.where(:age.gt => 30, :age.lt => 40).should == [person]
+      end
+
+      it "returns nothing if in and nin clauses cancel each other out" do
+        Person.any_in(:title => ["Sir"]).not_in(:title => ["Sir"]).should == []
+      end
+
+      it "returns nothing if in and nin clauses cancel each other out ordered the other way" do
+        Person.not_in(:title => ["Sir"]).any_in(:title => ["Sir"]).should == []
+      end
+
+      it "returns the intersection of in and nin clauses" do
+        Person.any_in(:title => ["Sir", "Mrs"]).not_in(:title => ["Mrs"]).should == [person]
+      end
+
+      it "returns the intersection of two in clauses" do
+        pending 'seems not work fo mongoid 3.0 (selector: {"title"=>{"$in"=>["Sir", "Ms"]})' if Mongoid::VERSION > '3'
+        Person.where(:title.in => ["Sir", "Mrs"]).where(:title.in => ["Sir", "Ms"]).should == [person]
+      end
+    end
+
+    context "with complex criterion" do
+
+      context "#all" do
+
+        it "returns those matching an all clause" do
+          Person.where(:aliases.all => ["D", "Durran"]).should == [person]
+        end
+      end
+
+      context "#exists" do
+
+        it "returns those matching an exists clause" do
+          Person.where(:title.exists => true).should == [person]
+        end
+      end
+
+      context "#gt" do
+
+        it "returns those matching a gt clause" do
+          Person.where(:age.gt => 30).should == [person]
+        end
+      end
+
+      context "#gte" do
+
+        it "returns those matching a gte clause" do
+          Person.where(:age.gte => 33).should == [person]
+        end
+      end
+
+      context "#in" do
+
+        it "returns those matching an in clause" do
+          Person.where(:title.in => ["Sir", "Madam"]).should == [person]
+        end
+
+        it "allows nil" do
+          Person.where(:ssn.in => [nil]).should == [person]
+        end
+      end
+
+      context "#lt" do
+
+        it "returns those matching a lt clause" do
+          Person.where(:age.lt => 34).should == [person]
+        end
+      end
+
+      context "#lte" do
+
+        it "returns those matching a lte clause" do
+          Person.where(:age.lte => 33).should == [person]
+        end
+      end
+
+      context "#ne" do
+
+        it "returns those matching a ne clause" do
+          Person.where(:age.ne => 50).should == [person]
+        end
+      end
+
+      context "#nin" do
+
+        it "returns those matching a nin clause" do
+          Person.where(:title.nin => ["Esquire", "Congressman"]).should == [person]
+        end
+      end
+
+      context "#size" do
+
+        it "returns those matching a size clause" do
+          query_key  = Mongoid::VERSION > '3' ? :aliases.with_size : :aliases.size
+          Person.where( query_key => 2).should == [person]
+        end
+      end
+
+      context "#match" do
+
+        it "returns those matching a partial element in a list" do
+          if Mongoid::VERSION > '3'
+            Person.where({'things.phone' => "HTC Incredible" }).should == [person]
+          else
+            Person.where(:things.matches => { :phone => "HTC Incredible" }).should == [person]
+          end
+        end
+      end
+
+    end
+
+    context "Geo Spatial Complex Where" do
+
+      let!(:home) do
+        [-73.98,40.77]
+      end
+
+      describe "#near" do
+        before do
+          Bar.delete_all
+          Bar.create_indexes
+        end
+
+        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
+
+        it "returns the documents sorted closest to furthest" do
+          Bar.where(:location.near => [ 41.23, 2.9 ]).should == [ paris, prague, berlin ]
+        end
+
+        it "returns the documents sorted closest to furthest" do
+          pending "NearSpatial#to_mongo_query seems not work for mongoid 3 " if Mongoid::VERSION > '3'
+          Bar.where(:location.near => {:point=>[ 41.23, 2.9 ],:max => 20}).should == [ paris, prague, berlin ]
+        end
+
+        it "returns the documents sorted closest to furthest" do
+          Bar.where(:location.near_sphere => [ 41.23, 2.9 ]).should == [ paris, prague, berlin ]
+        end
+
+        it "should find closest using rgeo point" do
+          Bar.where(:location.near => paris.location).to_a.should == [paris, berlin, prague]
+        end
+
+      end
+
+      context "#within" do
+
+        context ":box, :polygon" do
+          before do
+            Bar.delete_all
+            Bar.create_indexes
+          end
+
+          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 => 'prague',:location => [ 48.48, 2.20 ])
+          end
+
+          it "returns the documents within a box" do
+            Bar.where(:location.within(:box) => [[ 47, 1 ],[ 49, 3 ]]).should == [ paris ]
+          end
+
+          it "returns the documents within a polygon" do
+            Bar.where(:location.within(:polygon) => [[ 47, 1 ],[49,1.5],[ 49, 3 ],[46,5]]).should == [ paris ]
+          end
+
+          it "returns the documents within a center" do
+            Bar.where(:location.within(:center) => [[ 47, 1 ],4]).should == [ paris ]
+          end
+
+          it "returns the documents within a center_sphere" do
+            Bar.where(:location.within(:center_sphere) => [[ 48, 2 ],0.1]).should == [ paris ]
+          end
+
+        end
+        context ":circle :center_sphere" do
+          before do
+            Bar.delete_all
+            Bar.create_indexes
+          end
+          let!(:mile1) do
+            Bar.create(:name => 'mile1', :location => [-73.997345, 40.759382])
+          end
+
+          let!(:mile3) do
+            Bar.create(:name => 'mile2', :location => [-73.927088, 40.752151])
+          end
+
+          let!(:mile7) do
+            Bar.create(:name => 'mile3', :location => [-74.0954913, 40.7161472])
+          end
+
+          let!(:mile11) do
+            Bar.create(:name => 'mile4', :location => [-74.0604951, 40.9178011])
+          end
+
+          it "returns the documents within a center_sphere" do
+            Bar.where(:location.within(:center_sphere) => {:point => home,:max => 2, :unit => :mi}).should == [ mile1 ]
+          end
+
+          it "returns the documents within a center_sphere" do
+            Bar.where(:location.within(:center_sphere) => {:point => home,:max => 4, :unit => :mi}).should include(mile3)
+          end
+
+          it "returns the documents within a center_sphere" do
+            Bar.where(:location.within(:center_sphere) => {:point => home,:max => 8, :unit => :mi}).should include(mile7)
+          end
+
+          it "returns the documents within a center_sphere" do
+            Bar.where(:location.within(:center_sphere) => {:point => home,:max => 12, :unit => :mi}).should include(mile11)
+          end
+        end
+      end
+    end
+
+  end
+
+end

data/spec/mongoid_geospatial/fields/point_spec.rb

@@ -0,0 +1,34 @@
+require "spec_helper"
+
+describe Mongoid::Geospatial::Point do
+
+  describe "in use" do
+
+    it "should mongoize array" do
+      bar = Bar.new(location: [10, -9])
+      bar.location.class.should eql(RGeo::Geographic::SphericalPointImpl)
+      bar.location.x.should be_within(0.1).of(10)
+      bar.location.y.should be_within(0.1).of(-9)
+    end
+
+    it "should mongoize hash" do
+      bar = Bar.new(location: {x: 10, y: -9})
+      bar.location.class.should eql(RGeo::Geographic::SphericalPointImpl)
+      bar.location.x.should be_within(0.1).of(10)
+      bar.location.y.should be_within(0.1).of(-9)
+    end
+
+    describe "instantiated" do
+
+      let(:bar) { Bar.create!(name: 'Vitinho', location: [10,10]) }
+
+      it "should demongoize to rgeo" do
+        bar.location.class.should eql(RGeo::Geographic::SphericalPointImpl)
+      end
+
+    end
+
+  end
+
+
+end

data/spec/mongoid_geospatial/fields/polygon_spec.rb

@@ -0,0 +1,6 @@
+require "spec_helper"
+
+describe Mongoid::Geospatial::Polygon do
+
+
+end

data/spec/mongoid_geospatial/geospatial_spec.rb

@@ -18,6 +18,8 @@ describe Mongoid::Geospatial do
 
 
   context "Included" do
+
+    # HO
   end
 
 

data/spec/mongoid_geospatial/mongoid_geospatial_spec.rb

@@ -0,0 +1,83 @@
+require "spec_helper"
+
+describe Mongoid::Geospatial do
+
+  it "should not inferfer with mongoid" do
+    Bar.create!(name: "Moe's")
+    Bar.count.should eql(1)
+  end
+
+  describe "fields" do
+
+    it "should have a field mapped as point" do
+      bar = Bar.create!(location: [5,5])
+      bar.location.should be_a RGeo::Geographic::SphericalPointImpl
+    end
+
+    it "should support a field mapped as linestring" do
+      river = River.create!(source: [[5,5],[6,5],[6,6],[5,6]])
+      river.source.should be_a RGeo::Geographic::SphericalPolygonImpl
+    end
+
+    it "should support a field mapped as polygon" do
+      farm = Farm.create!(area: [[5,5],[6,5],[6,6],[5,6]])
+      farm.area.should be_a RGeo::Geographic::SphericalPolygonImpl
+    end
+
+
+    it "should accept an RGeo object" do
+      point = RGeo::Geographic.spherical_factory.point 1, 2
+      bar = Bar.create!(location: point)
+      bar.location.x.should be_within(0.1).of(1)
+      bar.location.y.should be_within(0.1).of(2)
+    end
+  end
+
+  describe "methods" do
+
+    it "should have a .to_a" do
+      bar = Bar.create!(location: [3,2])
+      bar.location.to_a[0..1].should == [3.0, 2.0]
+    end
+
+    it "should have an array [] accessor" do
+      bar = Bar.create!(location: [3,2])
+      bar.location[0].should == 3.0
+    end
+
+    it "should have an ActiveModel symbol accessor" do
+      bar = Bar.create!(location: [3,2])
+      bar[:location].should == [3,2]
+    end
+
+  end
+
+
+  it "should calculate distance between points" do
+    bar = Bar.create!(location: [5,5])
+    bar2 = Bar.create!(location: [15,15])
+    bar.location.distance(bar2.location).should be_within(1).of(1561283.8)
+  end
+
+  it "should calculate distance between points miles" do
+    pending
+    bar = Bar.create!(location: [5,5])
+    bar2 = Bar.create!(location: [15,15])
+    bar.location.distance(bar2.location).should be_within(1).of(1561283.8)
+  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)
+    bar.location.distance(bar2.location).to_i.should be_within(1).of(2469)
+  end
+
+  it "should have a nice simple way to ovewrite geo factory" do
+    pending
+    bar = Bar.create!(location: [5,5])
+    bar2 = Bar.create!(location: [15,15])
+    bar.location.distance(bar2.location).should be_within(1).of(1561283.8)
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -12,43 +12,59 @@ 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 "version: #{Mongoid::VERSION}"
+
+require 'mongoid_setup'
+
 Mongoid.configure do |config|
-  opts = YAML.load(File.read(File.dirname(__FILE__) + '/support/mongoid.yml'))["test"]
-  name = opts.delete("database")
-  host = opts.delete("host")
-  port = opts.delete("port")
-  config.master = Mongo::Connection.new(host, port, opts).db(name)
-  config.logger = nil
-  config.allow_dynamic_fields = true
+  Mongoid::VersionSetup.configure config
+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(MODELS, "*.rb") ].sort.each { |file| require File.basename(file) }
 Dir[ File.join(SUPPORT, "*.rb") ].each { |file| require File.basename(file) }
 
+def bson_object_id_class
+  Mongoid::VERSION > '3' ? Moped::BSON:: ObjectId : BSON::ObjectId
+end
+
 RSpec.configure do |config|
   config.mock_with(:mocha)
 
-  config.after(:suite) { Mongoid.purge! }
-  config.after(:each) do
-    Mongoid.database.collections.each do |collection|
-      unless collection.name =~ /^system\./
-        collection.remove
-      end
-    end
+  config.before(:each) do
+    Mongoid.purge!
+    # Mongoid.database.collections.each do |collection|
+    #   unless collection.name =~ /^system\./
+    #     collection.remove
+    #   end
+    # end
   end
 
   # We filter out the specs that require authentication if the database has not
   # had the mongoid user set up properly.
-  user_configured = Support::Authentication.configured?
-  warn(Support::Authentication.message) unless user_configured
+  # user_configured = Support::Authentication.configured?
+  # warn(Support::Authentication.message) unless user_configured
 
-  config.filter_run_excluding(:config => lambda { |value|
-    return true if value == :user && !user_configured
-  })
+  # config.filter_run_excluding(:config => lambda { |value|
+  #   return true if value == :user && !user_configured
+  # })
 end

data/spec/support/authentication.rb

@@ -1,29 +1,29 @@
 # encoding: utf-8
 module Support #:nodoc:
-  module Authentication
-    extend self
+  # 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 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:
+  #   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
+  #       $ use mongoid_geospatial_test;
+  #       $ db.addUser("mongoid", "test");
+  #     ---------------------------------------------------------------------
+  #     }
+  #   end
+  # end
 end