mongoid_geospatial 2.0.0 → 2.2.0

data/lib/mongoid_geospatial/version.rb

@@ -1,5 +1,5 @@
 module Mongoid
   module Geospatial
-    VERSION = "2.0.0"
+    VERSION = "2.2.0"
   end
 end

data/lib/mongoid_geospatial/wrappers/georuby.rb

@@ -0,0 +1,28 @@
+require 'georuby'
+# require 'mongoid_geospatial/extensions/georuby'
+
+module Mongoid
+  module Geospatial
+
+    class Point
+      def to_geo
+        GeoRuby::SimpleFeatures::Point.from_x_y(x, y)
+      end
+    end
+
+
+    class LineString < Array
+      def to_geo
+        GeoRuby::SimpleFeatures::LineString.from_array(self)
+      end
+
+    end
+
+    class Polygon < GeometryField
+      def to_geo
+        GeoRuby::SimpleFeatures::Polygon.from_array(self)
+      end
+
+    end
+  end
+end

data/lib/mongoid_geospatial/wrappers/rgeo.rb

@@ -0,0 +1,32 @@
+require 'rgeo'
+require 'mongoid_geospatial/extensions/rgeo_spherical_point_impl'
+
+module Mongoid
+  module Geospatial
+
+    class Point
+      def to_geo
+        RGeo::Geographic.spherical_factory.point x, y
+      end
+    end
+
+
+    class LineString < GeometryField
+      def to_geo
+        RGeo::Geographic.spherical_factory.line_string self
+      end
+
+    end
+
+    class Polygon < GeometryField
+      def to_geo
+        points = self.map do |pair|
+          RGeo::Geographic.spherical_factory.point *pair
+        end
+        ring = RGeo::Geographic.spherical_factory.linear_ring points
+        RGeo::Geographic.spherical_factory.polygon ring
+      end
+
+    end
+  end
+end

data/spec/models/farm.rb

@@ -2,8 +2,11 @@ class Farm
   include Mongoid::Document
   include Mongoid::Geospatial
 
-  field :name,              type: String
-  field :area,              type: Polygon,    spatial: true
+  field :name,         type: String
+  field :geom,         type: Point,    spatial: true
+  field :area,         type: Polygon,  spatial: true
+  field :m2,           type: Fixnum
 
+  spatial_index :geom
   spatial_index :area
 end

data/spec/models/person.rb

@@ -3,6 +3,7 @@ class Person
   include Mongoid::MultiParameterAttributes
   include Mongoid::Timestamps
   include Mongoid::Versioning
+  include Mongoid::Geospatial
 
   attr_accessor :mode
 
@@ -27,6 +28,9 @@ class Person
   field :reading, :type => Object
   field :bson_id, :type => bson_object_id_class
 
+  # Geo
+  field :location, :type => Point
+
   index age: 1
   index addresses: 1
   index dob: 1
@@ -49,21 +53,7 @@ class Person
     end
   end
 
-  # embeds_many :services
-
-
-  # has_many \
-  #   :posts,
-  #   :dependent => :delete,
-  #   :order => :rating.desc do
-  #   def extension
-  #     "Testing"
-  #   end
-  # end
-
   accepts_nested_attributes_for :addresses
-  accepts_nested_attributes_for :name, :update_only => true
-
 
   scope :minor, where(:age.lt => 18)
   scope :without_ssn, without(:ssn)

data/spec/models/phone.rb

@@ -1,9 +1,7 @@
 class Phone
   include Mongoid::Document
   field :number
-  if Mongoid::VERSION <  '3'
-    key :number
-  end
+
   embeds_one :country_code
   embedded_in :person
 end

data/spec/mongoid_geospatial/extensions/core_ext_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+
+describe "Core Extensions" do
+
+  describe Array do
+
+    it "should have a #to_xy method" do
+      [1,2,3].to_xy.should eql([1.0, 2.0])
+    end
+
+  end
+
+  describe Hash do
+
+    it "should have a #to_xy method" do
+      { x: 1.1, y: 2.1 }.to_xy.should eql([1.1, 2.1])
+    end
+
+  end
+end

data/spec/mongoid_geospatial/field_option_spec.rb

@@ -0,0 +1,11 @@
+require "spec_helper"
+
+describe Mongoid::Fields do
+
+  context "spatial" do
+  end
+
+  context "geom" do
+  end
+
+end

data/spec/mongoid_geospatial/fields/line_string_spec.rb

@@ -0,0 +1,40 @@
+require "spec_helper"
+
+describe Mongoid::Geospatial::LineString do
+
+  describe "(de)mongoize" do
+
+    it "should support a field mapped as linestring" do
+      river = River.new(source: [[5,5],[6,5],[6,6],[5,6]])
+      river.source.should be_a Mongoid::Geospatial::LineString
+      river.source.should eq([[5,5],[6,5],[6,6],[5,6]])
+    end
+
+    it "should support a field mapped as linestring" do
+      River.create!(source: [[5,5],[6,5],[6,6],[5,6]])
+      River.first.source.should 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]]
+      geom.bbox.should eq([[1,5], [6,6]])
+    end
+
+    it "should have a center point" do
+      geom = Mongoid::Geospatial::LineString.new [[1,1],[1,1],[9,9],[9,9]]
+      geom.center.should eq([5.5,5.5])
+    end
+
+    it "should have a radius helper" do
+      geom = Mongoid::Geospatial::LineString.new [[1,1],[1,1],[9,9],[9,9]]
+      geom.radius(10).should eq([[5.5,5.5], 10])
+    end
+
+    it "should have a radius sphere" do
+      geom = Mongoid::Geospatial::LineString.new [[1,1],[1,1],[9,9],[9,9]]
+      geom.radius_sphere(10)[1].should be_within(0.001).of(0.001569)
+    end
+
+  end
+
+end

data/spec/mongoid_geospatial/fields/point_spec.rb

@@ -2,30 +2,156 @@ require "spec_helper"
 
 describe Mongoid::Geospatial::Point do
 
-  describe "in use" do
+  it "should not inferfer with mongoid" do
+    Bar.create!(name: "Moe's")
+    Bar.count.should eql(1)
+  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
+        Bar.where(:location.near => jim.location).should == [ paris, prague, berlin ]
+      end
+
+      it "returns the documents sorted closest to furthest sphere" do
+        person = Person.new(:location => [ 41.23, 2.9 ])
+        Bar.where(:location.near_sphere => jim.location).should == [ paris, prague, berlin ]
+      end
+
+      it "returns the documents sorted closest to furthest with max" do
+        Bar.near(location: jim.location).max_distance(location: 10).to_a.should == [ 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 center_circle" do
+        Bar.where(:location.within_circle => [elvis.location, 250.0/Mongoid::Geospatial::EARTH_RADIUS_KM]).to_a.should == [ mile1 ]
+      end
+
+      it "returns the documents within a center_circle" do
+        Bar.where(:location.within_circle => [elvis.location, 500.0/Mongoid::Geospatial::EARTH_RADIUS_KM]).to_a.should include(mile3)
+      end
+
+      it "returns the documents within a center_sphere" do
+        Bar.where(:location.within_spherical_circle => [elvis.location, 0.0005]).to_a.should == [ mile1 ]
+      end
+
+      it "returns the documents within a center_sphere" do
+        Bar.where(:location.within_spherical_circle => [elvis.location, 0.5]).to_a.should include(mile9)
+      end
+    end
+
+  end
+
+  describe "(de)mongoize" do
 
     it "should mongoize array" do
       bar = Bar.new(location: [10, -9])
-      bar.location.class.should eql(RGeo::Geographic::SphericalPointImpl)
+      bar.location.class.should eql(Mongoid::Geospatial::Point)
       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)
+      geom = Bar.new(location: {x: 10, y: -9}).location
+      geom.class.should eql(Mongoid::Geospatial::Point)
+      geom.x.should be_within(0.1).of(10)
+      geom.y.should be_within(0.1).of(-9)
     end
 
-    describe "instantiated" do
 
-      let(:bar) { Bar.create!(name: 'Vitinho', location: [10,10]) }
+    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 demongoize to rgeo" do
-        bar.location.class.should eql(RGeo::Geographic::SphericalPointImpl)
+      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
+
+      it "should calculate distance between points" 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
+        pending
+        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
+
+    end
+
+    # should raise
+    # geom.to_geo
+
+    describe "with rgeo" do
+
+      describe "instantiated" do
+
+        let(:bar) { Bar.create!(name: 'Vitinho', location: [10,10]) }
+
+        it "should demongoize to rgeo" do
+          bar.location.class.should eql(Mongoid::Geospatial::Point)
+        end
+
+      end
+
+
     end
 
   end

data/spec/mongoid_geospatial/fields/polygon_spec.rb

@@ -2,5 +2,80 @@ require "spec_helper"
 
 describe Mongoid::Geospatial::Polygon do
 
+  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]])
+      farm.area.should eq([[5,5],[6,5],[6,6],[5,6]])
+      farm.area.should be_a Mongoid::Geospatial::Polygon
+    end
+
+    it "should store as array on mongo" do
+      Farm.create(area: [[5,5],[6,5],[6,6],[5,6]])
+      Farm.first.area.should 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]]
+      geom.bbox.should 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]]
+      geom.center.should eq([5.5,5.5])
+    end
+
+    it "should have a radius helper" do
+      geom = Mongoid::Geospatial::Polygon.new [[1,1],[1,1],[9,9],[9,9]]
+      geom.radius(10).should eq([[5.5,5.5], 10])
+    end
+
+    it "should have a radius sphere" do
+      geom = Mongoid::Geospatial::Polygon.new [[1,1],[1,1],[9,9],[9,9]]
+      geom.radius_sphere(10)[1].should 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]], :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])
+      end
+
+      it "returns the documents within a box" do
+        Farm.where(:geom.within_box => ranch.area ).to_a.should == [ ranch ]
+      end
+
+      it "returns the documents within a polygon" do
+        Farm.where(:geom.within_polygon => farm.area).to_a.should == [ farm ]
+      end
+
+      it "returns the documents within a center" do
+        Farm.where(:geom.within_circle => [ranch.geom, 0.4]).first.should eq(ranch)
+      end
+
+      it "returns the documents within a center_sphere" do
+        Farm.where(:geom.within_spherical_circle => [ranch.geom, 0.1]).first.should eq(ranch)
+      end
+
+    end
+
+  end
 
 end