georuby 2.2.1 → 2.3.0

data/spec/geo_ruby/gpx4r/gpx_spec.rb

@@ -3,10 +3,10 @@ require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
 describe GeoRuby::Gpx4r do
 
   it "should add gpx extension and raise if doesn't exists" do
-    lambda do
-      File.should_receive(:exists?).with("short.gpx").and_return(false)
-      GeoRuby::Gpx4r::GpxFile.open('short').should be_true
-    end.should raise_error GeoRuby::Gpx4r::MalformedGpxException
+    expect do
+      expect(File).to receive(:exists?).with("short.gpx").and_return(false)
+      expect(GeoRuby::Gpx4r::GpxFile.open('short')).to be_truthy
+    end.to raise_error GeoRuby::Gpx4r::MalformedGpxException
   end
 
   describe "Waypoints" do
@@ -18,75 +18,75 @@ describe GeoRuby::Gpx4r do
     end
 
     it "should open and parse" do
-      @gpxfile.record_count.should eql(2724)
+      expect(@gpxfile.record_count).to eql(2724)
     end
 
     it "should open and parse no trkpt one" do
-      @gpxfile2.record_count.should eql(86)
+      expect(@gpxfile2.record_count).to eql(86)
     end
 
     it "should open and parse 3" do
-      @gpxfile3.record_count.should eql(225)
+      expect(@gpxfile3.record_count).to eql(225)
     end
 
     it "should read X and Y" do
-      @gpxfile[0].x.should be_within(0.0001).of(9.093942)
-      @gpxfile[0].y.should be_within(0.0001).of(48.731813)
+      expect(@gpxfile[0].x).to be_within(0.0001).of(9.093942)
+      expect(@gpxfile[0].y).to be_within(0.0001).of(48.731813)
     end
 
     it "should read Z and M" do
-      @gpxfile[0].z.should eql(468.0)
-      @gpxfile[0].m.should eql("2008-09-07T17:36:57Z")
+      expect(@gpxfile[0].z).to eql(468.0)
+      expect(@gpxfile[0].m).to eql("2008-09-07T17:36:57Z")
     end
 
     it "should read X and Y 2" do
-      @gpxfile2[0].x.should be_within(0.0001).of(-71.119277)
-      @gpxfile2[0].y.should be_within(0.0001).of(42.438878)
+      expect(@gpxfile2[0].x).to be_within(0.0001).of(-71.119277)
+      expect(@gpxfile2[0].y).to be_within(0.0001).of(42.438878)
     end
 
     it "should read Z and M 2" do
-      @gpxfile2[0].z.should eql(44.586548)
-      @gpxfile2[0].m.should eql("2001-11-28T21:05:28Z")
+      expect(@gpxfile2[0].z).to eql(44.586548)
+      expect(@gpxfile2[0].m).to eql("2001-11-28T21:05:28Z")
     end
 
     it "should read X and Y 3" do
-      @gpxfile3[0].x.should be_within(0.0001).of(-149.8358011)
-      @gpxfile3[0].y.should be_within(0.0001).of(-17.5326508)
+      expect(@gpxfile3[0].x).to be_within(0.0001).of(-149.8358011)
+      expect(@gpxfile3[0].y).to be_within(0.0001).of(-17.5326508)
     end
 
     it "should read Z and M 3" do
-      @gpxfile3[0].z.should eql(88.5787354)
-      @gpxfile3[0].m.should eql(0.0)
+      expect(@gpxfile3[0].z).to eql(88.5787354)
+      expect(@gpxfile3[0].m).to eql(0.0)
     end
 
     it "should return it as a linestring" do
-      @gpxfile.as_line_string.should be_instance_of GeoRuby::SimpleFeatures::LineString
-      @gpxfile.as_polyline.should be_instance_of GeoRuby::SimpleFeatures::LineString
+      expect(@gpxfile.as_line_string).to be_instance_of GeoRuby::SimpleFeatures::LineString
+      expect(@gpxfile.as_polyline).to be_instance_of GeoRuby::SimpleFeatures::LineString
     end
 
     it "should return it as a linestring 3" do
-      @gpxfile3.as_line_string.should be_instance_of GeoRuby::SimpleFeatures::LineString
-      @gpxfile3.as_polyline.should be_instance_of GeoRuby::SimpleFeatures::LineString
+      expect(@gpxfile3.as_line_string).to be_instance_of GeoRuby::SimpleFeatures::LineString
+      expect(@gpxfile3.as_polyline).to be_instance_of GeoRuby::SimpleFeatures::LineString
     end
 
     it "should return a envelope" do
-      @gpxfile.envelope.should be_instance_of GeoRuby::SimpleFeatures::Envelope
-      @gpxfile.envelope.lower_corner.x.should be_within(0.001).of(9.08128)
-      @gpxfile.envelope.lower_corner.y.should be_within(0.001).of(48.7169)
+      expect(@gpxfile.envelope).to be_instance_of GeoRuby::SimpleFeatures::Envelope
+      expect(@gpxfile.envelope.lower_corner.x).to be_within(0.001).of(9.08128)
+      expect(@gpxfile.envelope.lower_corner.y).to be_within(0.001).of(48.7169)
     end
 
     it "should return a envelope 3" do
-      @gpxfile3.envelope.should be_instance_of GeoRuby::SimpleFeatures::Envelope
-      @gpxfile3.envelope.lower_corner.x.should be_within(0.001).of(-149.8422613)
-      @gpxfile3.envelope.lower_corner.y.should be_within(0.001).of(-17.547636)
+      expect(@gpxfile3.envelope).to be_instance_of GeoRuby::SimpleFeatures::Envelope
+      expect(@gpxfile3.envelope.lower_corner.x).to be_within(0.001).of(-149.8422613)
+      expect(@gpxfile3.envelope.lower_corner.y).to be_within(0.001).of(-17.547636)
     end
 
     it "should return it as a polygon" do
       [@gpxfile, @gpxfile2, @gpxfile3].each do |g|
-        g.as_polygon.should be_instance_of GeoRuby::SimpleFeatures::Polygon
-        g.as_polygon[0].should be_instance_of GeoRuby::SimpleFeatures::LinearRing
-        g.as_polygon[0].should be_closed
-        g.as_polygon[1].should be_nil
+        expect(g.as_polygon).to be_instance_of GeoRuby::SimpleFeatures::Polygon
+        expect(g.as_polygon[0]).to be_instance_of GeoRuby::SimpleFeatures::LinearRing
+        expect(g.as_polygon[0]).to be_closed
+        expect(g.as_polygon[1]).to be_nil
       end
     end
 
@@ -96,7 +96,7 @@ describe GeoRuby::Gpx4r do
       nw = GeoRuby::SimpleFeatures::Point.from_x_y(-42, -25)
       ne = GeoRuby::SimpleFeatures::Point.from_x_y(-44, -21)
       @gpxfile.instance_variable_set(:@points, [se,sw,nw,ne])
-      @gpxfile.as_polygon.should == GeoRuby::SimpleFeatures::Polygon.from_points([[se,sw,nw,ne,se]])
+      expect(@gpxfile.as_polygon).to eq(GeoRuby::SimpleFeatures::Polygon.from_points([[se,sw,nw,ne,se]]))
     end
   end
 

data/spec/geo_ruby/kml_spec.rb

@@ -20,59 +20,59 @@ describe GeoRuby::KmlParser do
   it "should parse a GeoRuby::SimpleFeatures::Point correctly" do
     @kml_parser.parse(POINT)
     g = @factory.geometry
-    g.should_not eql(nil)
-    g.should be_an_instance_of(GeoRuby::SimpleFeatures::Point)
-    g.as_kml.gsub(/\n/,'').should eql(POINT) 
+    expect(g).not_to eql(nil)
+    expect(g).to be_an_instance_of(GeoRuby::SimpleFeatures::Point)
+    expect(g.as_kml.gsub(/\n/,'')).to eql(POINT) 
   end
   
   it "should parse a GeoRuby::SimpleFeatures::LineString correctly" do
     @kml_parser.parse(LINESTRING)
     g = @factory.geometry
-    g.should_not eql(nil)
-    g.should be_an_instance_of(GeoRuby::SimpleFeatures::LineString)
-    g.as_kml.gsub(/\n/,'').should eql(LINESTRING)
+    expect(g).not_to eql(nil)
+    expect(g).to be_an_instance_of(GeoRuby::SimpleFeatures::LineString)
+    expect(g.as_kml.gsub(/\n/,'')).to eql(LINESTRING)
 
     @kml_parser.parse(LINEARRING)
     g = @factory.geometry
-    g.should_not eql(nil)
-    g.should be_an_instance_of(GeoRuby::SimpleFeatures::LinearRing)
-    g.as_kml.gsub(/\n/,'').should eql(LINEARRING)
+    expect(g).not_to eql(nil)
+    expect(g).to be_an_instance_of(GeoRuby::SimpleFeatures::LinearRing)
+    expect(g.as_kml.gsub(/\n/,'')).to eql(LINEARRING)
   end
   
   it "should parse a GeoRuby::SimpleFeatures::Polygon correctly" do
     @kml_parser.parse(POLYGON)
     g = @factory.geometry
-    g.should_not eql(nil)
-    g.should be_an_instance_of(GeoRuby::SimpleFeatures::Polygon)
-    g.as_kml.gsub(/\n/,'').should eql(POLYGON)
+    expect(g).not_to eql(nil)
+    expect(g).to be_an_instance_of(GeoRuby::SimpleFeatures::Polygon)
+    expect(g.as_kml.gsub(/\n/,'')).to eql(POLYGON)
 
     @kml_parser.parse(COMPLEX_POLYGON)
     g = @factory.geometry
-    g.should_not eql(nil)
-    g.should be_an_instance_of(GeoRuby::SimpleFeatures::Polygon)
-    g.as_kml.gsub(/\n/,'').should eql(COMPLEX_POLYGON)
+    expect(g).not_to eql(nil)
+    expect(g).to be_an_instance_of(GeoRuby::SimpleFeatures::Polygon)
+    expect(g.as_kml.gsub(/\n/,'')).to eql(COMPLEX_POLYGON)
   end
   
   it "should parse a MultiGeometry correctly" do
     @kml_parser.parse(MULTIGEOMETRY)
     g = @factory.geometry
-    g.should_not eql(nil)
-    g.geometries.length.should eql(2)
-    g.should be_an_instance_of(GeoRuby::SimpleFeatures::GeometryCollection)
-    g.as_kml.gsub(/\n/,'').should eql(MULTIGEOMETRY)
+    expect(g).not_to eql(nil)
+    expect(g.geometries.length).to eql(2)
+    expect(g).to be_an_instance_of(GeoRuby::SimpleFeatures::GeometryCollection)
+    expect(g.as_kml.gsub(/\n/,'')).to eql(MULTIGEOMETRY)
   end
   
   it "should parse 3D geometries correctly" do
     # not testing generation because GeoRuby kml generation logic currently requires additional
     # XML nodes to actually output 3D coordinate information.  I might modify that behavior
     g = @kml_parser.parse(POINT3D)
-    g.should_not eql(nil)
-    g.with_z.should eql(true)
+    expect(g).not_to eql(nil)
+    expect(g.with_z).to eql(true)
     # g.as_kml(:altitude_mode => "clampToGround").gsub(/\n/,'').should eql(POINT3D)
 
     g = @kml_parser.parse(LINESTRING3D)
-    g.should_not eql(nil)
-    g.with_z.should eql(true)
+    expect(g).not_to eql(nil)
+    expect(g.with_z).to eql(true)
     # g.as_kml(:altitude_mode => "clampToGround").gsub(/\n/,'').should eql(LINESTRING3D)
   end
 
@@ -80,9 +80,9 @@ describe GeoRuby::KmlParser do
     [LINESTRING, LINEARRING, POLYGON, COMPLEX_POLYGON, MULTIGEOMETRY, LINESTRING3D].each do |kml|
       @kml_parser.parse(kml)
       g = @factory.geometry
-      lambda {
+      expect {
         g.bounding_box
-      }.should_not raise_error
+      }.not_to raise_error
     end
   end
 
@@ -90,9 +90,9 @@ describe GeoRuby::KmlParser do
     [LINESTRING, LINEARRING, POLYGON, COMPLEX_POLYGON, MULTIGEOMETRY, LINESTRING3D].each do |kml|
       @kml_parser.parse(kml)
       g = @factory.geometry
-      lambda {
+      expect {
         g.envelope.center
-      }.should_not raise_error
+      }.not_to raise_error
     end
   end
 end

data/spec/geo_ruby/shp4r/shp_spec.rb

@@ -8,31 +8,31 @@ describe GeoRuby::Shp4r do
     end
 
     it "should parse ok" do
-      @shpfile.record_count.should eql(2)
-      @shpfile.should have(1).fields
-      @shpfile.shp_type.should eql(GeoRuby::Shp4r::ShpType::POINT)
+      expect(@shpfile.record_count).to eql(2)
+      expect(@shpfile.fields.size).to eq(1)
+      expect(@shpfile.shp_type).to eql(GeoRuby::Shp4r::ShpType::POINT)
     end
 
     it "should parse fields" do
       field = @shpfile.fields.first
-      field.name.should eql("Hoyoyo")
-      field.type.should eql("N")
+      expect(field.name).to eql("Hoyoyo")
+      expect(field.type).to eql("N")
     end
 
     it "should parse record 1" do
       rec = @shpfile[0]
-      rec.geometry.should be_kind_of GeoRuby::SimpleFeatures::Point
-      rec.geometry.x.should be_within(0.00001).of(-90.08375)
-      rec.geometry.y.should be_within(0.00001).of(34.39996)
-      rec.data["Hoyoyo"].should eql(6)
+      expect(rec.geometry).to be_kind_of GeoRuby::SimpleFeatures::Point
+      expect(rec.geometry.x).to be_within(0.00001).of(-90.08375)
+      expect(rec.geometry.y).to be_within(0.00001).of(34.39996)
+      expect(rec.data["Hoyoyo"]).to eql(6)
     end
 
     it "should parse record 2" do
       rec = @shpfile[1]
-      rec.geometry.should be_kind_of GeoRuby::SimpleFeatures::Point
-      rec.geometry.x.should be_within(0.00001).of(-87.82580)
-      rec.geometry.y.should be_within(0.00001).of(33.36416)
-      rec.data["Hoyoyo"].should eql(9)
+      expect(rec.geometry).to be_kind_of GeoRuby::SimpleFeatures::Point
+      expect(rec.geometry.x).to be_within(0.00001).of(-87.82580)
+      expect(rec.geometry.y).to be_within(0.00001).of(33.36416)
+      expect(rec.data["Hoyoyo"]).to eql(9)
     end
 
   end
@@ -43,25 +43,25 @@ describe GeoRuby::Shp4r do
     end
 
     it "should parse ok" do
-      @shpfile.record_count.should eql(1)
-      @shpfile.should have(1).fields
-      @shpfile.shp_type.should eql(GeoRuby::Shp4r::ShpType::POLYLINE)
+      expect(@shpfile.record_count).to eql(1)
+      expect(@shpfile.fields.size).to eq(1)
+      expect(@shpfile.shp_type).to eql(GeoRuby::Shp4r::ShpType::POLYLINE)
     end
 
     it "should parse fields" do
       field = @shpfile.fields.first
-      field.name.should eql("Chipoto")
+      expect(field.name).to eql("Chipoto")
       # GeoRuby::Shp4r::Dbf now uses the decimal to choose between int and float
       # So here is N instead of F
-      field.type.should eql("N")
+      expect(field.type).to eql("N")
     end
 
     it "should parse record 1" do
       rec = @shpfile[0]
-      rec.geometry.should be_kind_of GeoRuby::SimpleFeatures::MultiLineString
-      rec.geometry.length.should eql(1)
-      rec.geometry[0].length.should eql(6)
-      rec.data["Chipoto"].should eql(5.678)
+      expect(rec.geometry).to be_kind_of GeoRuby::SimpleFeatures::MultiLineString
+      expect(rec.geometry.length).to eql(1)
+      expect(rec.geometry[0].length).to eql(6)
+      expect(rec.data["Chipoto"]).to eql(5.678)
     end
 
   end
@@ -72,24 +72,24 @@ describe GeoRuby::Shp4r do
     end
 
     it "should parse ok" do
-      @shpfile.record_count.should eql(1)
-      @shpfile.should have(1).fields
-      @shpfile.shp_type.should eql(GeoRuby::Shp4r::ShpType::POLYGON)
+      expect(@shpfile.record_count).to eql(1)
+      expect(@shpfile.fields.size).to eq(1)
+      expect(@shpfile.shp_type).to eql(GeoRuby::Shp4r::ShpType::POLYGON)
     end
 
     it "should parse fields" do
       field = @shpfile.fields.first
-      field.name.should eql("Hello")
-      field.type.should eql("C")
+      expect(field.name).to eql("Hello")
+      expect(field.type).to eql("C")
     end
 
     it "should parse record 1" do
       rec = @shpfile[0]
-      rec.geometry.should be_kind_of GeoRuby::SimpleFeatures::MultiPolygon
-      rec.geometry.length.should eql(1)
-      rec.geometry[0].length.should eql(1)
-      rec.geometry[0][0].length.should eql(7)
-      rec.data["Hello"].should eql("Bouyoul!")
+      expect(rec.geometry).to be_kind_of GeoRuby::SimpleFeatures::MultiPolygon
+      expect(rec.geometry.length).to eql(1)
+      expect(rec.geometry[0].length).to eql(1)
+      expect(rec.geometry[0][0].length).to eql(7)
+      expect(rec.data["Hello"]).to eql("Bouyoul!")
     end
   end
 
@@ -112,13 +112,13 @@ describe GeoRuby::Shp4r do
       shpfile = GeoRuby::Shp4r::ShpFile.open(File.dirname(__FILE__) + '/../../data/point2.shp')
 
       shpfile.transaction do |tr|
-        tr.should be_instance_of GeoRuby::Shp4r::ShpTransaction
+        expect(tr).to be_instance_of GeoRuby::Shp4r::ShpTransaction
         tr.add(GeoRuby::Shp4r::ShpRecord.new(GeoRuby::SimpleFeatures::Point.from_x_y(123.4,123.4),'Hoyoyo' => 5))
         tr.add(GeoRuby::Shp4r::ShpRecord.new(GeoRuby::SimpleFeatures::Point.from_x_y(-16.67,16.41),'Hoyoyo' => -7))
         tr.delete(1)
       end
 
-      shpfile.record_count.should eql(3)
+      expect(shpfile.record_count).to eql(3)
 
       shpfile.close
       rm_all_shp(File.dirname(__FILE__) + '/../../data/point2')
@@ -131,13 +131,13 @@ describe GeoRuby::Shp4r do
       shpfile = GeoRuby::Shp4r::ShpFile.open(File.dirname(__FILE__) + '/../../data/polyline2.shp')
 
       shpfile.transaction do |tr|
-        tr.should be_instance_of GeoRuby::Shp4r::ShpTransaction
+        expect(tr).to be_instance_of GeoRuby::Shp4r::ShpTransaction
         tr.add(GeoRuby::Shp4r::ShpRecord.new(GeoRuby::SimpleFeatures::LineString.from_coordinates([[123.4,123.4],[45.6,12.3]]),'Chipoto' => 5.6778))
         tr.add(GeoRuby::Shp4r::ShpRecord.new(GeoRuby::SimpleFeatures::LineString.from_coordinates([[23.4,13.4],[45.6,12.3],[12,-67]]),'Chipoto' => -7.1))
         tr.delete(0)
       end
 
-      shpfile.record_count.should eql(2)
+      expect(shpfile.record_count).to eql(2)
       shpfile.close
       rm_all_shp(File.dirname(__FILE__) + '/../../data/polyline2')
     end
@@ -148,12 +148,12 @@ describe GeoRuby::Shp4r do
       shpfile = GeoRuby::Shp4r::ShpFile.open(File.dirname(__FILE__) + '/../../data/polygon2.shp')
 
       shpfile.transaction do |tr|
-        tr.should be_instance_of GeoRuby::Shp4r::ShpTransaction
+        expect(tr).to be_instance_of GeoRuby::Shp4r::ShpTransaction
         tr.delete(0)
         tr.add(GeoRuby::Shp4r::ShpRecord.new(GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[0,0],[40,0],[40,40],[0,40],[0,0]],[[10,10],[10,20],[20,20],[10,10]]]),'Hello' => "oook"))
       end
 
-      shpfile.record_count.should eql(1)
+      expect(shpfile.record_count).to eql(1)
 
       shpfile.close
       rm_all_shp(File.dirname(__FILE__) + '/../../data/polygon2')
@@ -165,11 +165,11 @@ describe GeoRuby::Shp4r do
       shpfile = GeoRuby::Shp4r::ShpFile.open(File.dirname(__FILE__) + '/../../data/multipoint2.shp')
 
       shpfile.transaction do |tr|
-        tr.should be_instance_of GeoRuby::Shp4r::ShpTransaction
+        expect(tr).to be_instance_of GeoRuby::Shp4r::ShpTransaction
         tr.add(GeoRuby::Shp4r::ShpRecord.new(GeoRuby::SimpleFeatures::MultiPoint.from_coordinates([[45.6,-45.1],[12.4,98.2],[51.2,-0.12],[156.12345,56.109]]),'Hello' => 5,"Hoyoyo" => "AEZAE"))
       end
 
-      shpfile.record_count.should eql(2)
+      expect(shpfile.record_count).to eql(2)
 
       shpfile.close
       rm_all_shp(File.dirname(__FILE__) + '/../../data/multipoint2')
@@ -182,11 +182,11 @@ describe GeoRuby::Shp4r do
       shpfile = GeoRuby::Shp4r::ShpFile.open(File.dirname(__FILE__) + '/../../data/polygon4.shp')
 
       shpfile.transaction do |tr|
-        tr.should be_instance_of GeoRuby::Shp4r::ShpTransaction
+        expect(tr).to be_instance_of GeoRuby::Shp4r::ShpTransaction
         tr.add(GeoRuby::Shp4r::ShpRecord.new(GeoRuby::SimpleFeatures::MultiPolygon.from_polygons([GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[0,0],[40,0],[40,40],[0,40],[0,0]],[[10,10],[10,20],[20,20],[10,10]]])]),'Hello' => "oook"))
       end
 
-      shpfile.record_count.should eql(2)
+      expect(shpfile.record_count).to eql(2)
 
       shpfile.close
 
@@ -200,11 +200,11 @@ describe GeoRuby::Shp4r do
       shpfile = GeoRuby::Shp4r::ShpFile.open(File.dirname(__FILE__) + '/../../data/polygon5.shp')
 
       shpfile.transaction do |tr|
-        tr.should be_instance_of GeoRuby::Shp4r::ShpTransaction
+        expect(tr).to be_instance_of GeoRuby::Shp4r::ShpTransaction
         tr.add(GeoRuby::Shp4r::ShpRecord.new(GeoRuby::SimpleFeatures::MultiPolygon.from_polygons([GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[0,0],[40,0],[40,40],[0,40],[0,0]],[[10,10],[10,20],[20,20],[10,10]]])]),'Hello' => "oook"))
         tr.rollback
       end
-      shpfile.record_count.should eql(1)
+      expect(shpfile.record_count).to eql(1)
 
       shpfile.close
 
@@ -217,7 +217,7 @@ describe GeoRuby::Shp4r do
       shpfile.transaction do |tr|
         tr.add(GeoRuby::Shp4r::ShpRecord.new(GeoRuby::SimpleFeatures::Point.from_x_y(123,123.4),'Hoyoyo' => "HJHJJ"))
       end
-      shpfile.record_count.should eql(1)
+      expect(shpfile.record_count).to eql(1)
       shpfile.close
       rm_all_shp(File.dirname(__FILE__) + '/../../data/point3')
     end
@@ -227,7 +227,7 @@ describe GeoRuby::Shp4r do
       shpfile.transaction do |tr|
         tr.add(GeoRuby::Shp4r::ShpRecord.new(GeoRuby::SimpleFeatures::MultiPoint.from_coordinates([[123,123.4],[345,12.2]]),'Hoyoyo' => "HJHJJ","Hello" => 5))
       end
-      shpfile.record_count.should eql(1)
+      expect(shpfile.record_count).to eql(1)
       shpfile.close
       rm_all_shp(File.dirname(__FILE__) + '/../../data/multipoint3')
     end