georuby-ext 0.0.1 → 0.0.2

data/spec/lib/georuby/rtree_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+describe GeoRuby::Rtree::STRBuilder do 
+
+  subject { GeoRuby::Rtree::STRBuilder.new points("0 2,1 1,2 0").reverse }
+
+  let(:element) { "element" }
+
+  def slice(points)
+    GeoRuby::Rtree::STRBuilder::Slice.new points(points)
+  end
+
+  def node(*children)
+    children = points(children.first) if children.size == 1 and String === children.first
+    GeoRuby::Rtree::Node.new children
+  end
+
+  describe "#root_node" do
+
+    it "should return ..." do
+      subject.root_node.should == node(node("1 1, 0 2"), node("2 0"))
+    end
+
+  end
+
+  describe "#leaf_nodes" do
+    it "should return nodes from slices" do
+      subject.stub :slices => [ slice("0 2, 1 1"), slice("2 0") ]
+      subject.leaf_nodes.should == [ node("1 1, 0 2"), node("2 0") ]
+    end
+  end
+
+  describe "#slices" do
+    it "should fill slices with sorted elements (by x)" do
+      subject.slices.should == [ slice("0 2, 1 1"), slice("2 0") ]
+    end                   
+
+    it "should return slices with specified size" do
+      subject.slices.each do |slice|
+        slice.size.should <= subject.slice_size
+      end
+    end
+  end
+
+  describe "#leaf_nodes_count" do
+
+    it "should return 10 for 39 elements with a node size of 4" do
+      GeoRuby::Rtree::STRBuilder.new([element] * 39, 4).leaf_nodes_count.should == 10
+    end
+
+  end
+
+  describe "#slice_size" do
+                       
+    it "should return 3 for 27 elements with a node size of 3" do
+      GeoRuby::Rtree::STRBuilder.new([element] * 27, 3).slice_size.should == 3
+    end
+
+    it "should return 4 for 30 elements with a node size of 3" do
+      GeoRuby::Rtree::STRBuilder.new([element] * 30, 3).slice_size.should == 4
+    end
+    
+  end
+
+end   
+
+
+describe GeoRuby::Rtree::STRBuilder::Slice do 
+
+  subject { GeoRuby::Rtree::STRBuilder::Slice.new points("2 0,1 1,0 2").reverse, 2 }
+
+  describe "#sort_y" do
+
+    it "should return elements classified by y" do
+      subject.sort_y.should == points("2 0, 1 1, 0 2")
+    end                      
+
+  end
+
+  describe "#nodes" do
+
+    def node(points)
+      GeoRuby::Rtree::Node.new points(points)
+    end
+
+    it "should fill nodes with sorted elements" do
+      subject.nodes.should == [ node("2 0, 1 1"), node("0 2") ]
+    end                      
+
+    it "should return nodes with specified size" do
+      subject.nodes.each do |node|
+        node.size.should <= subject.node_size
+      end
+    end
+
+  end
+
+end
+
+describe GeoRuby::Rtree::Node do 
+
+  describe "bounds" do
+
+    it "should return a global bounds of children" do
+      subject.children << polygon("(0 0,1 1,1 0,0 0)") 
+      subject.children << polygon("(1 1,2 2,2 0,1 1)") 
+
+      subject.bounds.should == envelope("0 0","2 2")
+    end                      
+
+  end
+
+  describe "#==" do
+    
+    it "should be true when children are the same" do
+      GeoRuby::Rtree::Node.new(1,2,3).should == GeoRuby::Rtree::Node.new(1,2,3)
+    end
+               
+  end
+
+  describe "#containing" do
+    bound = envelope("0 0","1 1")
+    let(:children) { [ polygon("(0 0,0 1,1 1,1 0,0 0)"), polygon("(0 0,0 2,2 2,2 0,0 0)"), polygon("(0 0,0 0.5,0.5 0.5,0.5 0,0 0)") ] }
+    
+    it "should return elements if containing bounds" do
+      GeoRuby::Rtree::Node.new(children).containing(bound).should == children
+    end
+               
+  end
+
+
+end

data/spec/lib/proj4_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+describe Proj4::Projection do
+  
+  describe ".for_srid" do
+    
+    it "should return wgs84 projection for srid 4326" do
+      Proj4::Projection.for_srid(4326).should == Proj4::Projection.wgs84
+    end
+
+    it "should return wgs84 projection for srid 900913" do
+      Proj4::Projection.for_srid(900913).should == Proj4::Projection.google
+    end
+
+    it "should raise an error when srid isn't supported" do
+      lambda do
+        Proj4::Projection.for_srid(123)
+      end.should raise_error
+    end
+
+  end
+
+
+end

data/spec/lib/rgeo/cartesian/feature_methods_spec.rb

@@ -0,0 +1,110 @@
+require "spec_helper"
+
+module RGeo
+  module Cartesian
+
+    describe PointImpl do
+      
+      subject { rgeo_point }
+      
+      describe "#to_georuby" do
+        
+        it "should return a GeoRuby::SimpleFeatures::Point" do
+          subject.to_georuby.should be_instance_of(GeoRuby::SimpleFeatures::Point)
+        end
+        
+        it "should have the same x, y and srid" do
+          subject.to_georuby.should have_same(:x, :y, :srid).than(subject)
+        end
+        
+      end
+      
+    end
+    
+    describe LineStringImpl do
+      
+      subject { rgeometry("LINESTRING(0 0, 1 1, 2 2)") }
+      
+      describe "#to_linear_ring" do
+        
+        it "should return a GeoRuby::SimpleFeatures::LinearRing" do                          
+          subject.to_linear_ring.should == rgeometry("LINESTRING(0 0, 1 1, 2 2, 0 0)")
+        end
+        
+      end
+      
+      describe "#to_georuby" do
+        
+        it "should return a GeoRuby::SimpleFeatures::LineString" do
+          subject.to_georuby.should be_instance_of(GeoRuby::SimpleFeatures::LineString)
+        end
+        
+        it "should return a LineString with the same information" do
+          subject.to_georuby.should == geometry("LINESTRING(0 0, 1 1, 2 2)")
+        end
+        
+      end
+      
+    end
+    
+    # describe RGeo::Geos::LinearRingImpl do
+
+    #   subject { rgeometry("LINEARRING(0 0, 1 1, 0 0)") }
+    
+    #   describe "#to_georuby" do
+    
+    #     it "should return a GeoRuby::SimpleFeatures::LineString" do
+    #       subject.to_georuby.should be_instance_of(GeoRuby::SimpleFeatures::LinearRing)
+    #     end
+    
+    #     it "should return a LineString with the same information" do
+    #       subject.to_georuby.should == geometry("LINEARRING(0 0, 1 1, 1 1)")
+    #     end
+    
+    #   end
+    
+    # end
+    
+    describe PolygonImpl do
+      
+      subject { rgeometry("POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))") }
+      
+      describe "#to_georuby" do
+        
+        it "should return a GeoRuby::SimpleFeatures::Polygon" do
+          subject.to_georuby.should be_instance_of(GeoRuby::SimpleFeatures::Polygon)
+        end
+        
+        it "should return a georuby polygon with the same information" do
+          subject.to_georuby.should == geometry("POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))")
+        end
+        
+        it "should return a georuby polygon with the same information" do
+          rgeo_polygon = rgeometry("POLYGON((0 0, 0 1, 1 1, 1 0, 0 0), (0.25 0.25,0 0.75,0.75 0.75,0.75 0.25))")
+          rgeo_polygon.to_georuby.should == geometry("POLYGON((0 0, 0 1, 1 1, 1 0, 0 0), (0.25 0.25,0 0.75,0.75 0.75,0.75 0.25))")
+        end
+        
+      end
+      
+    end
+
+    describe MultiPolygonImpl do
+      
+      subject { rgeometry("MULTIPOLYGON ( ((0 0, 0 1, 1 1, 1 0, 0 0), (0.25 0.25,0 0.75,0.75 0.75,0.75 0.25, 0.25 0.25)), ((15 5, 40 10, 10 20, 5 10, 15 5)) )") }
+      
+      describe "#to_georuby" do
+        
+        it "should return a GeoRuby::SimpleFeatures::MultiPolygon" do
+          subject.to_georuby.should be_instance_of(GeoRuby::SimpleFeatures::MultiPolygon)
+        end
+        
+        it "should return a MultiPolygon with the same information" do
+          subject.to_georuby.should == geometry("MULTIPOLYGON ( ((0 0, 0 1, 1 1, 1 0, 0 0), (0.25 0.25,0 0.75,0.75 0.75,0.75 0.25, 0.25 0.25)), ((15 5, 40 10, 10 20, 5 10, 15 5)) )")
+        end
+        
+      end
+      
+    end    
+    
+  end
+end

data/spec/lib/rgeo/geos/ffi_feature_methods_spec.rb

@@ -0,0 +1,234 @@
+require "spec_helper"
+
+module RGeo
+  module Geos
+
+    describe FFIPointImpl do
+      
+      subject { rgeo_point }
+      
+      describe "#to_georuby" do
+        
+        it "should return a GeoRuby::SimpleFeatures::Point" do
+          subject.to_georuby.should be_instance_of(GeoRuby::SimpleFeatures::Point)
+        end
+        
+        it "should have the same x, y and srid" do
+          subject.to_georuby.should have_same(:x, :y, :srid).than(subject)
+        end
+        
+      end
+      
+    end
+    
+    describe FFILineStringImpl do
+      
+      subject { rgeometry("LINESTRING(0 0, 1 1, 2 2)") }
+      
+      describe "#to_linear_ring" do
+        
+        it "should return a GeoRuby::SimpleFeatures::LinearRing" do                          
+          subject.to_linear_ring.should == rgeometry("LINESTRING(0 0, 1 1, 2 2, 0 0)")
+        end
+        
+      end
+      
+      describe "#to_georuby" do
+        
+        it "should return a GeoRuby::SimpleFeatures::LineString" do
+          subject.to_georuby.should be_instance_of(GeoRuby::SimpleFeatures::LineString)
+        end
+        
+        it "should return a LineString with the same information" do
+          subject.to_georuby.should == geometry("LINESTRING(0 0, 1 1, 2 2)")
+        end
+        
+      end
+
+      describe "#distance_on_line" do
+        
+        it "should return distance on line" do
+          #subject.stub :nearest_locator => 
+          #subject.distance_on_line().should == 
+        end
+
+      end
+
+      describe "#distance_from_line" do
+        
+        it "should return distance from line" do
+          #subject.distance_from_line().should == 
+        end
+
+      end
+      
+    end
+
+    describe RGeo::Geos::FFILineStringImpl::Segment do
+      subject { RGeo::Geos::FFILineStringImpl::Segment.new(rgeo_point(0, 1.0), rgeo_point(0, 2.0)) }
+
+      before :each do 
+        subject.stub :line_distance_at_departure => 1
+        subject.stub :line => rgeometry("LINESTRING(0 0, 0 1.0, 0 2.0)")
+      end
+      
+      describe "#line_distance_at_arrival" do
+        it "should return distance between departure and arrival for Segment" do
+          subject.line_distance_at_arrival.should == 2
+        end
+
+        it "should return distance between departure and arrival for Segment and line distance" do
+          subject.stub :line_distance_at_departure => 0
+          subject.line_distance_at_arrival.should == 1
+        end
+      end
+
+      describe "#location_in_line" do
+        it "should return the distance at the beginning of the segment" do
+          subject.location_in_line.should == 0.5
+        end
+      end
+      
+    end
+
+    describe RGeo::Geos::FFILineStringImpl::PointLocator do
+
+      let(:departure) { rgeo_point(0, 0) }
+      let(:arrival) { rgeo_point(2.0, 0) }
+      let(:point_on_segment) { rgeo_point(1.0, 0) }
+      
+      def locator(target, departure, arrival)
+        RGeo::Geos::FFILineStringImpl::PointLocator.new target, departure, arrival
+      end
+
+      describe "distance_from_segment" do
+
+        it "should be zero if target is on the segment" do
+          locator(departure, departure, arrival).distance_from_segment.should be_zero
+        end
+
+        it "should be 0 if target is on the middle of the segment" do
+          locator(point_on_segment, departure, arrival).distance_from_segment.should == 0
+        end
+
+        it "should be 1 if target is on the x axis of the middle of the segment" do
+          locator(rgeo_point(1.0,1.0), departure, arrival).distance_from_segment.should be_within(0.01).of(1.0)
+        end
+        
+      end
+
+      describe "distance_on_segment" do
+
+        it "should be zero if target is the departure" do
+          locator(departure, departure, arrival).distance_on_segment.should be_zero
+        end
+
+        it "should be 1 if target is on the middle of the segment" do
+          locator(point_on_segment, departure, arrival).distance_on_segment.should == 1.0
+        end
+
+        it "should be 1 if target is on the x axis of the middle of the segment" do
+          locator(rgeo_point(1.0,1.0), departure, arrival).distance_on_segment.should be_within(0.01).of(1.0)
+        end
+
+      end
+
+    end
+      
+      # describe RGeo::Geos::FFILinearRingImpl do
+
+      #   subject { rgeometry("LINEARRING(0 0, 1 1, 0 0)") }
+      
+      #   describe "#to_georuby" do
+      
+      #     it "should return a GeoRuby::SimpleFeatures::LineString" do
+      #       subject.to_georuby.should be_instance_of(GeoRuby::SimpleFeatures::LinearRing)
+      #     end
+      
+      #     it "should return a LineString with the same information" do
+      #       subject.to_georuby.should == geometry("LINEARRING(0 0, 1 1, 1 1)")
+      #     end
+      
+      #   end
+      
+      # end
+      
+    describe FFIPolygonImpl do
+      
+      subject { rgeometry("POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))") }
+      
+      describe "#to_georuby" do
+        
+        it "should return a GeoRuby::SimpleFeatures::Polygon" do
+          subject.to_georuby.should be_instance_of(GeoRuby::SimpleFeatures::Polygon)
+        end
+        
+        it "should return a georuby polygon with the same information" do
+          subject.to_georuby.should == geometry("POLYGON((0 0, 0 1, 1 1, 1 0, 0 0))")
+        end
+        
+        it "should return a georuby polygon with the same information" do
+          rgeo_polygon = rgeometry("POLYGON((0 0, 0 1, 1 1, 1 0, 0 0), (0.25 0.25,0 0.75,0.75 0.75,0.75 0.25))")
+          rgeo_polygon.to_georuby.should == geometry("POLYGON((0 0, 0 1, 1 1, 1 0, 0 0), (0.25 0.25,0 0.75,0.75 0.75,0.75 0.25))")
+        end
+        
+      end
+      
+    end
+    
+    describe RGeo::Geos::FFIMultiLineStringImpl do
+      
+      describe "locate_point" do
+        
+        context "examples" do
+          
+          # it "should find 2,1 at 0.5 between 0,0 and 4,0" do
+          #   multi_line_string("(0 0,4 0)").locate_point(point(2,1)).should == 0.5
+          # end
+
+          # it "should find 2,1 at 1.5 for (0,4)...(0,1) and (0,0)...(4,0)" do
+          #   multi_line_string("(0 4,0 1),(0 0,4 0)").locate_point(point(2,1)).should == 1.5
+          # end
+          
+        end
+
+      end
+
+      # describe "interpolate_point" do
+      
+      #   context "examples" do
+
+      #     it "should find 0.5 at (2,0) between 0,0 and 4,0" do
+      #       rgeometry("MULTILINESTRING((0 0,4 0))").interpolate_point(0.5).should == point(2,0)
+      #     end
+
+      #     it "should find 1.5 at (2,0) for (0,4)...(0,1) and (0,0)...(4,0)" do
+      #       rgeometry("MULTILINESTRING((0 4,0 1),(0 0,4 0))").interpolate_point(1.5).should == point(2,0)
+      #     end
+      
+      #   end
+
+      # end
+
+    end
+
+    
+    describe FFIMultiPolygonImpl do
+      
+      subject { rgeometry("MULTIPOLYGON ( ((0 0, 0 1, 1 1, 1 0, 0 0), (0.25 0.25,0 0.75,0.75 0.75,0.75 0.25, 0.25 0.25)), ((15 5, 40 10, 10 20, 5 10, 15 5)) )") }
+      
+      describe "#to_georuby" do
+        
+        it "should return a GeoRuby::SimpleFeatures::MultiPolygon" do
+          subject.to_georuby.should be_instance_of(GeoRuby::SimpleFeatures::MultiPolygon)
+        end
+        
+        it "should return a MultiPolygon with the same information" do
+          subject.to_georuby.should == geometry("MULTIPOLYGON ( ((0 0, 0 1, 1 1, 1 0, 0 0), (0.25 0.25,0 0.75,0.75 0.75,0.75 0.25, 0.25 0.25)), ((15 5, 40 10, 10 20, 5 10, 15 5)) )")
+        end
+        
+      end      
+    end  
+      
+  end
+end