georuby 2.2.1 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1df3941993b62765a00e7f70707184ef283c189a
-  data.tar.gz: 14626bcff00c29e6ac59747d54501e2d0e5b4be7
+  metadata.gz: 1f642a6426275ec6a200705f9314ac60b783ec66
+  data.tar.gz: ce8ae36da2895144752587caa3c0ddc9ad190a9b
 SHA512:
-  metadata.gz: 98448b91aa33033dc06db092a68e72d1e04a0dcad9c895cd34953c78acc9da96c28adbb74d3c951c835a98c2f01cfaa658d1f9028f127e282f05bc89c7dc7ff5
-  data.tar.gz: 2bba7b1eed46c75f3871508f82b4015803eef2617d1d474fcfe4dd3c7830c054d9a88c9f6e5b5e5121cb43da9129d376366a0d94c1ae0dc542d72cad404c8c78
+  metadata.gz: eaa948c90a6d82850fd9aa0f571ea947b1cbc77d049faf6db86b855c93eea37e5e8dc3a5730ebcc8d8ee399ed73f81fc92dc20615e5e42e93ca392065969a688
+  data.tar.gz: 013276cf42be227087ae1ef62b54b8d25bddb1d91da560ac617903176482b62f258fcf853f22657facad18e974ccd6317665b34584f3cb47f02efb541fc43730

data/README.md

@@ -132,7 +132,7 @@ GeoRuby does not allow the modification of the schema (it will probably be done
 
 Here is an example of how to create a new Shapefile with 2 fields :
 
-      shpfile = ShpFile.create('hello.shp',ShpType::POINT,[Dbf::Field.new("Hoyoyo","C",10),Dbf::Field.new("Boyoul","N",10,0)])
+      shpfile = ShpFile.create('hello.shp',ShpType::POINT,[DBF::Field.new("Hoyoyo","C",10), DBF::Field.new("Boyoul","N",10,0)])
 
 The file is then open for reading and writing.
 
@@ -171,10 +171,11 @@ Basic GeoJSON support has been implemented per v1.0 of the {spec}[http://geojson
 
 USAGE:
 
- input - GeoRuby::SimpleFeatures::Geometry.from_geojson(geojson_string)
- output - call #as_geojson or #to_json on any SimpleFeature Geometry instance
+ input - `GeoRuby::SimpleFeatures::Geometry.from_geojson(geojson_string)`
+ output - call `#as_geojson` or `#to_json` on any SimpleFeature Geometry instance
 
 TODO:
+
  * Refactor to support extremely large GeoJSON input streams / files. Currently
    the entire GeoJSON representation must be loaded into memory as a String
  * Improve srid/crs support on input and add support on output
@@ -184,29 +185,33 @@ TODO:
 GeoJSON support implemented by {Marcus Mateus}[http://github.com/marcusmateus] and released courtesy {SimpliTex}[http://simplitex.com].
 
 
-=== Extra Features
+### Extra Features
 
 - Writing of ESRI shapefiles
 - Reading of ESRI shapefiles
 - Tool to import spatial features in MySQL and PostGIS from a SHP file
 
 
-=== Acknowledgement
+### Acknowledgement
 
 The SHP reading part uses the DBF library (http://rubyforge.org/projects/dbf/) by Keith Morrison (http://infused.org).
 Thanks also to Pramukta Kumar and Pete Schwamb for their contributions.
 
 
-== Support (Original GeoRuby gem)
+## Support (Original GeoRuby gem)
 
 Any questions, enhancement proposals, bug notifications or corrections
-can be sent to mailto:guilhem.vellut@gmail.com.
+can be sent to guilhem.vellut@gmail.com.
 
 
-=== Coming in the next versions
+### Coming in the next versions
 
 - Schema modification of existing shapefiles
 - More error reporting when writing shapefiles
 - More tests on writing shapefiles ; tests on real-world shapefiles
 - Better shp2sql import tool
 - Documentation
+
+
+[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/nofxx/georuby/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
+

data/lib/geo_ruby/geojson.rb

@@ -8,7 +8,7 @@ rescue LoadError
 end
 
 module GeoRuby
-  
+
   #Raised when an error in the GeoJSON string is detected
   class GeojsonFormatError < StandardError
   end
@@ -37,7 +37,7 @@ module GeoRuby
       output[:geometry] = geometry
       output[:properties] = properties
       output[:id] = id unless id.nil?
-      output.as_json(options)
+      output.to_json(options)
     end
 
     def to_json(options = {})
@@ -65,11 +65,11 @@ module GeoRuby
       true
     end
 
-    def to_json(options = {})
+    def as_json(options = {})
       {:type => 'FeatureCollection',
         :features => features}.to_json(options)
     end
-    alias :as_geojson :to_json
+    alias :as_geojson :as_json
   end
 
 
@@ -138,5 +138,7 @@ module GeoRuby
       end
       return nil
     end
-  end
-end
+
+  end #GeojsonParser
+
+end #GeoRuby

data/lib/geo_ruby/simple_features/geometry.rb

@@ -155,6 +155,17 @@ module GeoRuby#:nodoc:
         kml_representation(options.merge(:id_attr => id_attr, :geom_data => geom_data, :allow_z => allow_z, :fixed_z => fixed_z))
       end
 
+      # simple geojson representation
+      # TODO add CRS / SRID support?
+      def to_json(options = {})
+        as_json(options).to_json(options)
+      end
+
+      def as_json(options = {})
+        # Implemented by each class
+      end
+      alias :as_geojson :as_json
+
       # Creates a geometry based on a EWKB string. The actual class returned depends of the content of the string passed as argument. Since WKB strings are a subset of EWKB, they are also valid.
       def self.from_ewkb(ewkb)
         factory = GeometryFactory::new

data/lib/geo_ruby/simple_features/geometry_collection.rb

@@ -103,17 +103,9 @@ module GeoRuby
       end
 
       def as_json(options = {})
-        {:type => 'GeometryCollection',
-         :geometries => self.geometries}
+        {:type => 'GeometryCollection', :geometries => self.geometries}
       end
 
-      # simple geojson representation
-      # TODO add CRS / SRID support?
-      def to_json(options = {})
-        as_json(options).to_json(options)
-      end
-      alias :as_geojson :to_json
-
       #georss simple representation : outputs only the first geometry of the collection
       def georss_simple_representation(options)#:nodoc:
         self[0].georss_simple_representation(options)

data/lib/geo_ruby/simple_features/line_string.rb

@@ -199,21 +199,13 @@ module GeoRuby
       end
 
       def to_coordinates
-        points.map{|p| p.to_coordinates }
+        points.map { |p| p.to_coordinates }
       end
 
       def as_json(options = {})
-        {:type => 'LineString',
-         :coordinates => self.to_coordinates}
+        {:type => 'LineString', :coordinates => self.to_coordinates}
       end
 
-      # simple geojson representation
-      # TODO add CRS / SRID support?
-      def to_json(options = {})
-        as_json(options).to_json(options)
-      end
-      alias :as_geojson :to_json
-
       #Creates a new line string. Accept an array of points as argument
       def self.from_points(points,srid=DEFAULT_SRID,with_z=false,with_m=false)
         line_string = new(srid,with_z,with_m)
@@ -227,6 +219,9 @@ module GeoRuby
         line_string.concat( points.map {|p| Point.from_coordinates(p,srid,with_z,with_m) } )
         line_string
       end
-    end
-  end
-end
+
+    end #LineString
+
+  end #SimpleFeatures
+
+end #GeoRuby

data/lib/geo_ruby/simple_features/multi_line_string.rb

@@ -32,23 +32,15 @@ module GeoRuby
       def to_line_string(join = true)
         LineString.from_points(points)
       end
-      
+
       def to_coordinates
         geometries.map{|ls| ls.to_coordinates}
       end
 
       def as_json(options = {})
-        {:type => 'MultiLineString',
-         :coordinates => self.to_coordinates}
+        {:type => 'MultiLineString', :coordinates => self.to_coordinates}
       end
 
-      # simple geojson representation
-      # TODO add CRS / SRID support?
-      def to_json(options = {})
-        as_json(options).to_json(options)
-      end
-      alias :as_geojson :to_json
-      
       #Creates a new multi line string from an array of line strings
       def self.from_line_strings(line_strings,srid=DEFAULT_SRID,with_z=false,with_m=false)
         multi_line_string = new(srid,with_z,with_m)

data/lib/geo_ruby/simple_features/multi_point.rb

@@ -32,17 +32,9 @@ module GeoRuby
       end
 
       def as_json(options = {})
-        {:type => 'MultiPoint',
-         :coordinates => self.to_coordinates}
+        {:type => 'MultiPoint', :coordinates => self.to_coordinates}
       end
 
-      # simple geojson representation
-      # TODO add CRS / SRID support?
-      def to_json(options = {})
-        as_json(options).to_json(options)
-      end
-      alias :as_geojson :to_json
-
       #Creates a new multi point from an array of points
       def self.from_points(points,srid= DEFAULT_SRID,with_z=false,with_m=false)
         multi_point= new(srid,with_z,with_m)

data/lib/geo_ruby/simple_features/multi_polygon.rb

@@ -40,13 +40,6 @@ module GeoRuby
          :coordinates => self.to_coordinates}
       end
 
-      # simple geojson representation
-      # TODO add CRS / SRID support?
-      def to_json(options = {})
-        as_json(options).to_json(options)
-      end
-      alias :as_geojson :to_json
-
       #Creates a multi polygon from an array of polygons
       def self.from_polygons(polygons,srid=DEFAULT_SRID,with_z=false,with_m=false)
         multi_polygon = new(srid,with_z,with_m)

data/lib/geo_ruby/simple_features/point.rb

@@ -332,6 +332,11 @@ module GeoRuby
         [r, t]
       end
 
+      # Outputs the point in json format
+      def as_json(options = {})
+        {:type => 'Point', :coordinates => self.to_coordinates }
+      end
+
       # Invert signal of all coordinates
       def -@
         set_x_y_z(-@x, -@y, -@z)
@@ -356,17 +361,6 @@ module GeoRuby
         [x, y, z]
       end
 
-      def as_json(options = {})
-        { :type => 'Point', :coordinates => self.to_coordinates }
-      end
-
-      # Simple geojson representation
-      # TODO add CRS / SRID support?
-      def to_json(options = {})
-        as_json(options).to_json(options)
-      end
-      alias :as_geojson :to_json
-
       # Creates a point from an array of coordinates
       def self.from_coordinates(coords, srid = DEFAULT_SRID, with_z = false, with_m = false)
         if ! (with_z || with_m)
@@ -441,6 +435,9 @@ module GeoRuby
         alias :from_lon_lat_z_m :from_x_y_z_m
         alias :from_rad_tet     :from_r_t
       end
-    end
-  end
-end
+
+    end #Point
+
+  end #SimpleFeatures
+
+end #GeoRuby

data/lib/geo_ruby/simple_features/polygon.rb

@@ -140,17 +140,9 @@ module GeoRuby
       end
 
       def as_json(options = {})
-        {:type => 'Polygon',
-         :coordinates => self.to_coordinates}
+        {:type => 'Polygon', :coordinates => self.to_coordinates }
       end
 
-      # simple geojson representation
-      # TODO add CRS / SRID support?
-      def to_json(options = {})
-        as_json(options).to_json(options)
-      end
-      alias :as_geojson :to_json
-
       #creates a new polygon. Accepts an array of linear strings as argument
       def self.from_linear_rings(linear_rings,srid = DEFAULT_SRID,with_z=false,with_m=false)
         polygon = new(srid,with_z,with_m)

data/lib/geo_ruby/version.rb

@@ -1,3 +1,3 @@
 module GeoRuby
-  VERSION = '2.2.1'
+  VERSION = '2.3.0'
 end

data/spec/geo_ruby/geojson_spec.rb

@@ -12,17 +12,17 @@ describe GeoRuby::GeojsonParser do
   it "should create a specified GeoRuby::SimpleFeatures::Point" do
     point_json = %{ { "type": "Point", "coordinates": [100.0, 0.0] } }
     point = GeoRuby::SimpleFeatures::Geometry.from_geojson(point_json)
-    point.class.should eql(GeoRuby::SimpleFeatures::Point)
+    expect(point.class).to eql(GeoRuby::SimpleFeatures::Point)
     point_hash = JSON.parse(point_json)
-    point.to_coordinates.should eql(point_hash['coordinates'])
+    expect(point.to_coordinates).to eql(point_hash['coordinates'])
   end
 
   it "should create a specified GeoRuby::SimpleFeatures::LineString" do
     ls_json = %{ { "type": "LineString", "coordinates": [ [100.0, 0.0], [101.0, 1.0] ]} }
     line_string = GeoRuby::SimpleFeatures::Geometry.from_geojson(ls_json)
-    line_string.class.should eql(GeoRuby::SimpleFeatures::LineString)
+    expect(line_string.class).to eql(GeoRuby::SimpleFeatures::LineString)
     ls_hash = JSON.parse(ls_json)
-    line_string.to_coordinates.should eql(ls_hash['coordinates'])
+    expect(line_string.to_coordinates).to eql(ls_hash['coordinates'])
   end
 
   it "should create a specified GeoRuby::SimpleFeatures::Polygon" do
@@ -35,10 +35,10 @@ describe GeoRuby::GeojsonParser do
       }
     EOJ
     polygon = GeoRuby::SimpleFeatures::Geometry.from_geojson(poly_json)
-    polygon.class.should eql(GeoRuby::SimpleFeatures::Polygon)
-    polygon.rings.size.should eql(2)
+    expect(polygon.class).to eql(GeoRuby::SimpleFeatures::Polygon)
+    expect(polygon.rings.size).to eql(2)
     poly_hash = JSON.parse(poly_json)
-    polygon.to_coordinates.should eql(poly_hash['coordinates'])
+    expect(polygon.to_coordinates).to eql(poly_hash['coordinates'])
   end
 
   it "should create a specified GeoRuby::SimpleFeatures::MultiPoint" do
@@ -48,9 +48,9 @@ describe GeoRuby::GeojsonParser do
         }
     EOJ
     multi_point = GeoRuby::SimpleFeatures::Geometry.from_geojson(mp_json)
-    multi_point.class.should eql(GeoRuby::SimpleFeatures::MultiPoint)
+    expect(multi_point.class).to eql(GeoRuby::SimpleFeatures::MultiPoint)
     mp_hash = JSON.parse(mp_json)
-    multi_point.to_coordinates.should eql(mp_hash['coordinates'])
+    expect(multi_point.to_coordinates).to eql(mp_hash['coordinates'])
   end
 
   it "should create a specified GeoRuby::SimpleFeatures::MultiLineString" do
@@ -63,9 +63,9 @@ describe GeoRuby::GeojsonParser do
       }
     EOJ
     multi_ls = GeoRuby::SimpleFeatures::Geometry.from_geojson(mls_json)
-    multi_ls.class.should eql(GeoRuby::SimpleFeatures::MultiLineString)
+    expect(multi_ls.class).to eql(GeoRuby::SimpleFeatures::MultiLineString)
     mls_hash = JSON.parse(mls_json)
-    multi_ls.to_coordinates.should eql(mls_hash['coordinates'])
+    expect(multi_ls.to_coordinates).to eql(mls_hash['coordinates'])
   end
 
   it "should create a specifiead GeoRuby::SimpleFeatures::MultiPolygon" do
@@ -79,9 +79,9 @@ describe GeoRuby::GeojsonParser do
         }
     EOJ
     mpoly = GeoRuby::SimpleFeatures::Geometry.from_geojson(mpoly_json)
-    mpoly.class.should eql(GeoRuby::SimpleFeatures::MultiPolygon)
+    expect(mpoly.class).to eql(GeoRuby::SimpleFeatures::MultiPolygon)
     mpoly_hash = JSON.parse(mpoly_json)
-    mpoly.to_coordinates.should eql(mpoly_hash['coordinates'])
+    expect(mpoly.to_coordinates).to eql(mpoly_hash['coordinates'])
   end
 
   it "should create a specified GeoRuby::SimpleFeatures::GeometryCollection" do
@@ -98,12 +98,12 @@ describe GeoRuby::GeojsonParser do
       }
     EOJ
     gcol = GeoRuby::SimpleFeatures::Geometry.from_geojson(gcol_json)
-    gcol.class.should eql(GeoRuby::SimpleFeatures::GeometryCollection)
+    expect(gcol.class).to eql(GeoRuby::SimpleFeatures::GeometryCollection)
     gcol_hash = JSON.parse(gcol_json)
     gcol.geometries.each_with_index do |g,i|
       gh = gcol_hash['geometries'][i]
-      g.class.should eql(GeoRuby::SimpleFeatures.const_get(gh['type']))
-      g.to_coordinates.should eql(gh['coordinates'])
+      expect(g.class).to eql(GeoRuby::SimpleFeatures.const_get(gh['type']))
+      expect(g.to_coordinates).to eql(gh['coordinates'])
     end
   end
 
@@ -121,25 +121,25 @@ describe GeoRuby::GeojsonParser do
       }
     EOJ
     f = GeoRuby::SimpleFeatures::Geometry.from_geojson(feature_json)
-    f.class.should eql(GeoRuby::GeojsonFeature)
+    expect(f.class).to eql(GeoRuby::GeojsonFeature)
     feature_hash = JSON.parse(feature_json)
-    f.id.should eql(feature_hash['id'])
-    f.properties.should eql(feature_hash['properties'])
-    f.geometry.class.should eql(GeoRuby::SimpleFeatures.const_get(feature_hash['geometry']['type']))
-    f.geometry.to_coordinates.should eql(feature_hash['geometry']['coordinates'])
+    expect(f.id).to eql(feature_hash['id'])
+    expect(f.properties).to eql(feature_hash['properties'])
+    expect(f.geometry.class).to eql(GeoRuby::SimpleFeatures.const_get(feature_hash['geometry']['type']))
+    expect(f.geometry.to_coordinates).to eql(feature_hash['geometry']['coordinates'])
   end
 
   it "should create a specified FeatureCollection" do
     fcol_json = File.read(DATA_DIR + 'feature_collection.json')
     fcol = GeoRuby::SimpleFeatures::Geometry.from_geojson(fcol_json)
-    fcol.class.should eql(GeoRuby::GeojsonFeatureCollection)
+    expect(fcol.class).to eql(GeoRuby::GeojsonFeatureCollection)
     fcol_hash = JSON.parse(fcol_json)
     fcol.features.each_with_index do |f,i|
       fgh = fcol_hash['features'][i]['geometry']
       fg = f.geometry
-      f.properties.should eql(fcol_hash['features'][i]['properties'])
-      fg.class.should eql(GeoRuby::SimpleFeatures.const_get(fgh['type']))
-      fg.to_coordinates.should eql(fgh['coordinates'])
+      expect(f.properties).to eql(fcol_hash['features'][i]['properties'])
+      expect(fg.class).to eql(GeoRuby::SimpleFeatures.const_get(fgh['type']))
+      expect(fg.to_coordinates).to eql(fgh['coordinates'])
     end
   end
 

data/spec/geo_ruby/georss_spec.rb

@@ -6,27 +6,27 @@ describe GeoRuby::GeorssParser do
 
   it "should parse an rss file" do
     geo = subject.parse(File.read(RSS_DATA_DIR + "/w3c.xml"))
-    geo.should be_a GeoRuby::SimpleFeatures::Point
+    expect(geo).to be_a GeoRuby::SimpleFeatures::Point
   end
 
   it "test_point_creation" do
     point = GeoRuby::SimpleFeatures::Point.from_x_y(3,4)
 
-    point.as_georss(:dialect => :simple, :elev => 45.7, :featuretypetag => "hoyoyo").gsub("\n","").should eql("<georss:point featuretypetag=\"hoyoyo\" elev=\"45.7\">4 3</georss:point>")
-    point.as_georss(:dialect => :w3cgeo).gsub("\n","").should eql("<geo:lat>4</geo:lat><geo:long>3</geo:long>")
-    point.as_georss(:dialect => :gml).gsub("\n","").should eql("<georss:where><gml:Point><gml:pos>4 3</gml:pos></gml:Point></georss:where>")
+    expect(point.as_georss(:dialect => :simple, :elev => 45.7, :featuretypetag => "hoyoyo").gsub("\n","")).to eql("<georss:point featuretypetag=\"hoyoyo\" elev=\"45.7\">4 3</georss:point>")
+    expect(point.as_georss(:dialect => :w3cgeo).gsub("\n","")).to eql("<geo:lat>4</geo:lat><geo:long>3</geo:long>")
+    expect(point.as_georss(:dialect => :gml).gsub("\n","")).to eql("<georss:where><gml:Point><gml:pos>4 3</gml:pos></gml:Point></georss:where>")
 
-    point.as_kml(:id => "HOYOYO-42").gsub("\n","").should eql("<Point id=\"HOYOYO-42\"><coordinates>3,4</coordinates></Point>")
+    expect(point.as_kml(:id => "HOYOYO-42").gsub("\n","")).to eql("<Point id=\"HOYOYO-42\"><coordinates>3,4</coordinates></Point>")
   end
 
   it "test_line_string" do
     ls = GeoRuby::SimpleFeatures::LineString.from_points([GeoRuby::SimpleFeatures::Point.from_lon_lat_z(12.4,-45.3,56),GeoRuby::SimpleFeatures::Point.from_lon_lat_z(45.4,41.6,45)],123,true)
 
-    ls.as_georss.gsub("\n","").should eql("<georss:line>-45.3 12.4 41.6 45.4</georss:line>")
-    ls.as_georss(:dialect => :w3cgeo).gsub("\n","").should eql("<geo:lat>-45.3</geo:lat><geo:long>12.4</geo:long>")
-    ls.as_georss(:dialect => :gml).gsub("\n","").should eql("<georss:where><gml:LineString><gml:posList>-45.3 12.4 41.6 45.4</gml:posList></gml:LineString></georss:where>")
+    expect(ls.as_georss.gsub("\n","")).to eql("<georss:line>-45.3 12.4 41.6 45.4</georss:line>")
+    expect(ls.as_georss(:dialect => :w3cgeo).gsub("\n","")).to eql("<geo:lat>-45.3</geo:lat><geo:long>12.4</geo:long>")
+    expect(ls.as_georss(:dialect => :gml).gsub("\n","")).to eql("<georss:where><gml:LineString><gml:posList>-45.3 12.4 41.6 45.4</gml:posList></gml:LineString></georss:where>")
 
-    ls.as_kml(:extrude => 1, :altitude_mode => "absolute").gsub("\n","").should eql("<LineString><extrude>1</extrude><altitudeMode>absolute</altitudeMode><coordinates>12.4,-45.3,56 45.4,41.6,45</coordinates></LineString>")
+    expect(ls.as_kml(:extrude => 1, :altitude_mode => "absolute").gsub("\n","")).to eql("<LineString><extrude>1</extrude><altitudeMode>absolute</altitudeMode><coordinates>12.4,-45.3,56 45.4,41.6,45</coordinates></LineString>")
   end
 
   it "test_polygon" do
@@ -34,22 +34,22 @@ describe GeoRuby::GeorssParser do
     linear_ring2 = GeoRuby::SimpleFeatures::LinearRing.from_coordinates([[2.4,5.3],[5.4,1.4263],[14.46,1.06],[2.4,5.3]],256)
     polygon = GeoRuby::SimpleFeatures::Polygon.from_linear_rings([linear_ring1,linear_ring2],256)
 
-    polygon.as_georss(:georss_ns => "hoyoyo").gsub("\n","").should eql("<hoyoyo:polygon>-45.3 12.4 41.6 45.4 1.0698 4.456 -45.3 12.4</hoyoyo:polygon>")
-    polygon.as_georss(:dialect => :w3cgeo, :w3cgeo_ns => "bouyoul").gsub("\n","").should eql("<bouyoul:lat>-45.3</bouyoul:lat><bouyoul:long>12.4</bouyoul:long>")
-    polygon.as_georss(:dialect => :gml).gsub("\n","").should eql("<georss:where><gml:Polygon><gml:exterior><gml:LinearRing><gml:posList>-45.3 12.4 41.6 45.4 1.0698 4.456 -45.3 12.4</gml:posList></gml:LinearRing></gml:exterior></gml:Polygon></georss:where>")
+    expect(polygon.as_georss(:georss_ns => "hoyoyo").gsub("\n","")).to eql("<hoyoyo:polygon>-45.3 12.4 41.6 45.4 1.0698 4.456 -45.3 12.4</hoyoyo:polygon>")
+    expect(polygon.as_georss(:dialect => :w3cgeo, :w3cgeo_ns => "bouyoul").gsub("\n","")).to eql("<bouyoul:lat>-45.3</bouyoul:lat><bouyoul:long>12.4</bouyoul:long>")
+    expect(polygon.as_georss(:dialect => :gml).gsub("\n","")).to eql("<georss:where><gml:Polygon><gml:exterior><gml:LinearRing><gml:posList>-45.3 12.4 41.6 45.4 1.0698 4.456 -45.3 12.4</gml:posList></gml:LinearRing></gml:exterior></gml:Polygon></georss:where>")
 
-    polygon.as_kml.gsub("\n","").should eql("<Polygon><outerBoundaryIs><LinearRing><coordinates>12.4,-45.3 45.4,41.6 4.456,1.0698 12.4,-45.3</coordinates></LinearRing></outerBoundaryIs><innerBoundaryIs><LinearRing><coordinates>2.4,5.3 5.4,1.4263 14.46,1.06 2.4,5.3</coordinates></LinearRing></innerBoundaryIs></Polygon>")
+    expect(polygon.as_kml.gsub("\n","")).to eql("<Polygon><outerBoundaryIs><LinearRing><coordinates>12.4,-45.3 45.4,41.6 4.456,1.0698 12.4,-45.3</coordinates></LinearRing></outerBoundaryIs><innerBoundaryIs><LinearRing><coordinates>2.4,5.3 5.4,1.4263 14.46,1.06 2.4,5.3</coordinates></LinearRing></innerBoundaryIs></Polygon>")
   end
 
   it "test_geometry_collection" do
     gc = GeoRuby::SimpleFeatures::GeometryCollection.from_geometries([GeoRuby::SimpleFeatures::Point.from_x_y(4.67,45.4,256),GeoRuby::SimpleFeatures::LineString.from_coordinates([[5.7,12.45],[67.55,54]],256)],256)
 
     #only the first geometry is output
-    gc.as_georss(:dialect => :simple,:floor => 4).gsub("\n","").should eql("<georss:point floor=\"4\">45.4 4.67</georss:point>")
-    gc.as_georss(:dialect => :w3cgeo).gsub("\n","").should eql("<geo:lat>45.4</geo:lat><geo:long>4.67</geo:long>")
-    gc.as_georss(:dialect => :gml).gsub("\n","").should eql("<georss:where><gml:Point><gml:pos>45.4 4.67</gml:pos></gml:Point></georss:where>")
+    expect(gc.as_georss(:dialect => :simple,:floor => 4).gsub("\n","")).to eql("<georss:point floor=\"4\">45.4 4.67</georss:point>")
+    expect(gc.as_georss(:dialect => :w3cgeo).gsub("\n","")).to eql("<geo:lat>45.4</geo:lat><geo:long>4.67</geo:long>")
+    expect(gc.as_georss(:dialect => :gml).gsub("\n","")).to eql("<georss:where><gml:Point><gml:pos>45.4 4.67</gml:pos></gml:Point></georss:where>")
 
-    gc.as_kml(:id => "HOYOYO-42").gsub("\n","").should eql("<MultiGeometry id=\"HOYOYO-42\"><Point><coordinates>4.67,45.4</coordinates></Point><LineString><coordinates>5.7,12.45 67.55,54</coordinates></LineString></MultiGeometry>")
+    expect(gc.as_kml(:id => "HOYOYO-42").gsub("\n","")).to eql("<MultiGeometry id=\"HOYOYO-42\"><Point><coordinates>4.67,45.4</coordinates></Point><LineString><coordinates>5.7,12.45 67.55,54</coordinates></LineString></MultiGeometry>")
   end
 
   it "test_envelope" do
@@ -59,53 +59,53 @@ describe GeoRuby::GeorssParser do
 
     e = polygon.envelope
 
-    e.as_georss(:dialect => :simple).gsub("\n","").should eql("<georss:box>-45 4 41 45</georss:box>")
+    expect(e.as_georss(:dialect => :simple).gsub("\n","")).to eql("<georss:box>-45 4 41 45</georss:box>")
     #center
-    e.as_georss(:dialect => :w3cgeo).gsub("\n","").should eql("<geo:lat>-2</geo:lat><geo:long>24</geo:long>")
-    e.as_georss(:dialect => :gml).gsub("\n","").should eql("<georss:where><gml:Envelope><gml:LowerCorner>-45 4</gml:LowerCorner><gml:UpperCorner>41 45</gml:UpperCorner></gml:Envelope></georss:where>")
+    expect(e.as_georss(:dialect => :w3cgeo).gsub("\n","")).to eql("<geo:lat>-2</geo:lat><geo:long>24</geo:long>")
+    expect(e.as_georss(:dialect => :gml).gsub("\n","")).to eql("<georss:where><gml:Envelope><gml:LowerCorner>-45 4</gml:LowerCorner><gml:UpperCorner>41 45</gml:UpperCorner></gml:Envelope></georss:where>")
 
-    e.as_kml.gsub("\n","").should eql("<LatLonAltBox><north>41</north><south>-45</south><east>45</east><west>4</west><minAltitude>-5.4</minAltitude><maxAltitude>34</maxAltitude></LatLonAltBox>")
+    expect(e.as_kml.gsub("\n","")).to eql("<LatLonAltBox><north>41</north><south>-45</south><east>45</east><west>4</west><minAltitude>-5.4</minAltitude><maxAltitude>34</maxAltitude></LatLonAltBox>")
   end
 
   it "test_point_georss_read" do
     #W3CGeo
     str = "   <geo:lat >12.3</geo:lat >\n\t  <geo:long>   4.56</geo:long> "
     geom = GeoRuby::SimpleFeatures::Geometry.from_georss(str)
-    geom.class.should eql(GeoRuby::SimpleFeatures::Point)
-    geom.lat.should eql(12.3)
-    geom.lon.should eql(4.56)
+    expect(geom.class).to eql(GeoRuby::SimpleFeatures::Point)
+    expect(geom.lat).to eql(12.3)
+    expect(geom.lon).to eql(4.56)
 
     str = " <geo:Point> \n \t  <geo:long>   4.56</geo:long> \n\t  <geo:lat >12.3</geo:lat > </geo:Point>  "
     geom = GeoRuby::SimpleFeatures::Geometry.from_georss(str)
-    geom.class.should eql(GeoRuby::SimpleFeatures::Point)
-    geom.lat.should eql(12.3)
-    geom.lon.should eql(4.56)
+    expect(geom.class).to eql(GeoRuby::SimpleFeatures::Point)
+    expect(geom.lat).to eql(12.3)
+    expect(geom.lon).to eql(4.56)
 
     #gml
     str = " <georss:where> \t\r  <gml:Point  > \t <gml:pos> 4 \t 3 </gml:pos> </gml:Point> </georss:where>"
     geom = GeoRuby::SimpleFeatures::Geometry.from_georss(str)
-    geom.class.should eql(GeoRuby::SimpleFeatures::Point)
-    geom.lat.should eql(4.0)
-    geom.lon.should eql(3.0)
+    expect(geom.class).to eql(GeoRuby::SimpleFeatures::Point)
+    expect(geom.lat).to eql(4.0)
+    expect(geom.lon).to eql(3.0)
 
     #simple
     str = "<georss:point > 4 \r\t  3 \t</georss:point >"
     geom  = GeoRuby::SimpleFeatures::Geometry.from_georss(str)
-    geom.class.should eql(GeoRuby::SimpleFeatures::Point)
-    geom.lat.should eql(4.0)
-    geom.lon.should eql(3.0)
+    expect(geom.class).to eql(GeoRuby::SimpleFeatures::Point)
+    expect(geom.lat).to eql(4.0)
+    expect(geom.lon).to eql(3.0)
 
     #simple with tags
     str = "<georss:point featuretypetag=\"hoyoyo\"  elev=\"45.7\" \n floor=\"2\" relationshiptag=\"puyopuyo\" radius=\"42\" > 4 \n 3 \t</georss:point >"
     geom,tags = GeoRuby::SimpleFeatures::Geometry.from_georss_with_tags(str)
-    geom.class.should eql(GeoRuby::SimpleFeatures::Point)
-    geom.lat.should eql(4.0)
-    geom.lon.should eql(3.0)
-    tags.featuretypetag.should eql("hoyoyo")
-    tags.elev.should eql(45.7)
-    tags.relationshiptag.should eql("puyopuyo")
-    tags.floor.should eql(2)
-    tags.radius.should eql(42.0)
+    expect(geom.class).to eql(GeoRuby::SimpleFeatures::Point)
+    expect(geom.lat).to eql(4.0)
+    expect(geom.lon).to eql(3.0)
+    expect(tags.featuretypetag).to eql("hoyoyo")
+    expect(tags.elev).to eql(45.7)
+    expect(tags.relationshiptag).to eql("puyopuyo")
+    expect(tags.floor).to eql(2)
+    expect(tags.radius).to eql(42.0)
   end
 
   it "test_line_string_georss_read" do
@@ -113,13 +113,13 @@ describe GeoRuby::GeorssParser do
 
     str = "<georss:line > -45.3 12.4 \n \r41.6\t 45.4</georss:line>"
     geom  = GeoRuby::SimpleFeatures::Geometry.from_georss(str)
-    geom.class.should eql(GeoRuby::SimpleFeatures::LineString)
-    ls.should == geom
+    expect(geom.class).to eql(GeoRuby::SimpleFeatures::LineString)
+    expect(ls).to eq(geom)
 
     str = "<georss:where><gml:LineString><gml:posList>-45.3 12.4 41.6 45.4</gml:posList></gml:LineString></georss:where>"
     geom = GeoRuby::SimpleFeatures::Geometry.from_georss(str)
-    geom.class.should eql(GeoRuby::SimpleFeatures::LineString)
-    ls.should == geom
+    expect(geom.class).to eql(GeoRuby::SimpleFeatures::LineString)
+    expect(ls).to eq(geom)
   end
 
   it "test_polygon_georss_read" do
@@ -128,13 +128,13 @@ describe GeoRuby::GeorssParser do
 
     str = "<hoyoyo:polygon featuretypetag=\"42\"  > -45.3 12.4 41.6 \n\r 45.4 1.0698 \r 4.456 -45.3 12.4 </hoyoyo:polygon>"
     geom = GeoRuby::SimpleFeatures::Geometry.from_georss(str)
-    geom.class.should eql(GeoRuby::SimpleFeatures::Polygon)
-    polygon.should == geom
+    expect(geom.class).to eql(GeoRuby::SimpleFeatures::Polygon)
+    expect(polygon).to eq(geom)
 
     str = "<georss:where>\r\t \n  <gml:Polygon><gml:exterior>   <gml:LinearRing><gml:posList> -45.3 \n\r 12.4 41.6 \n\t 45.4 1.0698 4.456 -45.3 12.4</gml:posList></gml:LinearRing></gml:exterior></gml:Polygon></georss:where>"
     geom = GeoRuby::SimpleFeatures::Geometry.from_georss(str)
-    geom.class.should eql(GeoRuby::SimpleFeatures::Polygon)
-    polygon.should == geom
+    expect(geom.class).to eql(GeoRuby::SimpleFeatures::Polygon)
+    expect(polygon).to eq(geom)
   end
 
   it "test_envelope_georss_read" do
@@ -142,19 +142,19 @@ describe GeoRuby::GeorssParser do
 
     str = "<georss:box  >-45.3 4.456 \n41.6 45.4</georss:box>"
     geom = GeoRuby::SimpleFeatures::Geometry.from_georss(str)
-    geom.class.should eql(GeoRuby::SimpleFeatures::Envelope)
-    geom.should == e
+    expect(geom.class).to eql(GeoRuby::SimpleFeatures::Envelope)
+    expect(geom).to eq(e)
 
     str = "<georss:where><gml:Envelope><gml:lowerCorner>-45.3 \n 4.456</gml:lowerCorner><gml:upperCorner>41.6 \t\n 45.4</gml:upperCorner></gml:Envelope></georss:where>"
     geom = GeoRuby::SimpleFeatures::Geometry.from_georss(str)
-    geom.class.should eql(GeoRuby::SimpleFeatures::Envelope)
-    geom.should == e
+    expect(geom.class).to eql(GeoRuby::SimpleFeatures::Envelope)
+    expect(geom).to eq(e)
   end
 
   it "reads KML" do
     g = GeoRuby::SimpleFeatures::Geometry.from_kml("<Point><coordinates>45,12,25</coordinates></Point>")
-    g.should be_a GeoRuby::SimpleFeatures::Point
-    g.should == GeoRuby::SimpleFeatures::Point.from_x_y_z('45','12','25')
+    expect(g).to be_a GeoRuby::SimpleFeatures::Point
+    expect(g).to eq(GeoRuby::SimpleFeatures::Point.from_x_y_z('45','12','25'))
 
     g = GeoRuby::SimpleFeatures::Geometry.from_kml("<LineString>
       <extrude>1</extrude>
@@ -163,9 +163,9 @@ describe GeoRuby::GeorssParser do
         -122.364383,37.824664,0 -122.364152,37.824322,0
       </coordinates>
     </LineString>")
-    g.should be_a GeoRuby::SimpleFeatures::LineString
-    g.length.should eql(2)
-    g.should == GeoRuby::SimpleFeatures::LineString.from_points([GeoRuby::SimpleFeatures::Point.from_x_y_z('-122.364383','37.824664','0'),GeoRuby::SimpleFeatures::Point.from_x_y_z('-122.364152','37.824322','0')],4326,true)
+    expect(g).to be_a GeoRuby::SimpleFeatures::LineString
+    expect(g.length).to eql(2)
+    expect(g).to eq(GeoRuby::SimpleFeatures::LineString.from_points([GeoRuby::SimpleFeatures::Point.from_x_y_z('-122.364383','37.824664','0'),GeoRuby::SimpleFeatures::Point.from_x_y_z('-122.364152','37.824322','0')],4326,true))
 
     g = GeoRuby::SimpleFeatures::Geometry.from_kml("<Polygon>
       <extrude>1</extrude>
@@ -204,23 +204,23 @@ describe GeoRuby::GeorssParser do
         </LinearRing>
       </innerBoundaryIs>
     </Polygon>")
-    g.should be_a GeoRuby::SimpleFeatures::Polygon
-    g.length.should eql(3)
+    expect(g).to be_a GeoRuby::SimpleFeatures::Polygon
+    expect(g.length).to eql(3)
   end
 
   it "does not raise type error if point geom data not provided" do
     point = GeoRuby::SimpleFeatures::Point.from_coordinates([1.6,2.8],123)
-    lambda { point.kml_representation }.should_not raise_error
+    expect { point.kml_representation }.not_to raise_error
   end
 
   it "does not raise type error if polygon geom data not provided" do
     polygon =  GeoRuby::SimpleFeatures::Polygon.from_coordinates([[[12.4,-45.3],[45.4,41.6],[4.456,1.0698],[12.4,-45.3]],[[2.4,5.3],[5.4,1.4263],[14.46,1.06],[2.4,5.3]]],256)
-    lambda { polygon.kml_representation }.should_not raise_error
+    expect { polygon.kml_representation }.not_to raise_error
   end
 
   it "does not raise type error if linestring geom data not provided" do
     ls = GeoRuby::SimpleFeatures::LineString.from_coordinates([[5.7,12.45],[67.55,54]],256)
-    lambda { ls.kml_representation }.should_not raise_error
+    expect { ls.kml_representation }.not_to raise_error
   end
 
 end