georuby 2.3.0 → 2.5.1

data/lib/geo_ruby/simple_features/geometry_collection.rb

@@ -2,21 +2,21 @@ require 'geo_ruby/simple_features/geometry'
 
 module GeoRuby
   module SimpleFeatures
-    #Represents a collection of arbitrary geometries
+    # Represents a collection of arbitrary geometries
     class GeometryCollection < Geometry
       attr_reader :geometries
 
-      def initialize(srid = DEFAULT_SRID,with_z=false,with_m=false)
-        super(srid,with_z,with_m)
+      def initialize(srid = DEFAULT_SRID, with_z = false, with_m = false)
+        super(srid, with_z, with_m)
         @geometries = []
       end
 
-      #Delegate the unknown methods to the geometries array
-      def method_missing(method_name,*args,&b)
-        @geometries.send(method_name,*args,&b)
+      # Delegate the unknown methods to the geometries array
+      def method_missing(method_name, *args, &b)
+        @geometries.send(method_name, *args, &b)
       end
 
-      #Bounding box in 2D/3D. Returns an array of 2 points
+      # Bounding box in 2D/3D. Returns an array of 2 points
       def bounding_box
         max_x, min_x, max_y, min_y = -Float::MAX, Float::MAX, -Float::MAX, Float::MAX
         if with_z
@@ -33,7 +33,7 @@ module GeoRuby
             max_z = ne.z if ne.z > max_z
             min_z = sw.z if sw.z < min_z
           end
-          [Point.from_x_y_z(min_x,min_y,min_z),Point.from_x_y_z(max_x,max_y,max_z)]
+          [Point.from_x_y_z(min_x, min_y, min_z), Point.from_x_y_z(max_x, max_y, max_z)]
         else
           each do |geometry|
             bbox = geometry.bounding_box
@@ -45,7 +45,7 @@ module GeoRuby
             max_x = ne.x if ne.x > max_x
             min_x = sw.x if sw.x < min_x
           end
-          [Point.from_x_y(min_x,min_y),Point.from_x_y(max_x,max_y)]
+          [Point.from_x_y(min_x, min_y), Point.from_x_y(max_x, max_y)]
         end
       end
 
@@ -57,81 +57,84 @@ module GeoRuby
             max_m = lrmr[1] if lrmr[1] > max_m
             min_m = lrmr[0] if lrmr[0] < min_m
           end
-          [min_m,max_m]
+          [min_m, max_m]
         else
-          [0,0]
+          [0, 0]
         end
       end
 
-      #tests the equality of geometry collections
-      def ==(other_collection)
-        if(other_collection.class != self.class)
+      # tests the equality of geometry collections
+      def ==(other)
+        if (other.class != self.class)
           false
-        elsif length != other_collection.length
+        elsif length != other.length
           false
         else
-          index=0
-          while index<length
-            return false if self[index] != other_collection[index]
-            index+=1
+          index = 0
+          while index < length
+            return false if self[index] != other[index]
+            index += 1
           end
           true
         end
       end
 
-      #Binary representation of the collection
-      def binary_representation(allow_z=true,allow_m=true) #:nodoc:
-        rep = [length].pack("V")
-        #output the list of geometries without outputting the SRID first and with the same setting regarding Z and M
-        each {|geometry| rep << geometry.as_ewkb(false,allow_z,allow_m) }
+      # Binary representation of the collection
+      def binary_representation(allow_z = true, allow_m = true) #:nodoc:
+        rep = [length].pack('V')
+        # output the list of geometries without outputting the SRID first
+        # and with the same setting regarding Z and M
+        each { |geometry| rep << geometry.as_ewkb(false, allow_z, allow_m) }
         rep
       end
 
-      #WKB geometry type of the collection
+      # WKB geometry type of the collection
       def binary_geometry_type #:nodoc:
         7
       end
 
-      #Text representation of a geometry collection
-      def text_representation(allow_z=true,allow_m=true) #:nodoc:
-        @geometries.collect{|geometry| geometry.as_ewkt(false,allow_z,allow_m)}.join(",")
+      # Text representation of a geometry collection
+      def text_representation(allow_z = true, allow_m = true) #:nodoc:
+        @geometries.collect do |geometry|
+          geometry.as_ewkt(false, allow_z, allow_m)
+        end.join(',')
       end
 
-      #WKT geometry type
+      # WKT geometry type
       def text_geometry_type #:nodoc:
-        "GEOMETRYCOLLECTION"
+        'GEOMETRYCOLLECTION'
       end
 
-      def as_json(options = {})
-        {:type => 'GeometryCollection', :geometries => self.geometries}
+      def as_json(_options = {})
+        { type: 'GeometryCollection', geometries: geometries }
       end
 
-      #georss simple representation : outputs only the first geometry of the collection
-      def georss_simple_representation(options)#:nodoc:
+      # georss simple representation : outputs only the first geometry of the collection
+      def georss_simple_representation(options) #:nodoc:
         self[0].georss_simple_representation(options)
       end
-      #georss w3c representation : outputs the first point of the outer ring
-      def georss_w3cgeo_representation(options)#:nodoc:
+      # georss w3c representation : outputs the first point of the outer ring
+      def georss_w3cgeo_representation(options) #:nodoc:
         self[0].georss_w3cgeo_representation(options)
       end
-      #georss gml representation : outputs only the first geometry of the collection
-      def georss_gml_representation(options)#:nodoc:
+      # georss gml representation : outputs only the first geometry of the collection
+      def georss_gml_representation(options) #:nodoc:
         self[0].georss_gml_representation(options)
       end
 
-      #outputs the geometry in kml format
+      # outputs the geometry in kml format
       def kml_representation(options = {}) #:nodoc:
         result = "<MultiGeometry#{options[:id_attr]}>\n"
-        options[:id_attr] = "" #the subgeometries do not have an ID
+        options[:id_attr] = '' # the subgeometries do not have an ID
         each do |geometry|
           result += geometry.kml_representation(options)
         end
         result += "</MultiGeometry>\n"
       end
 
-      #creates a new GeometryCollection from an array of geometries
-      def self.from_geometries(geometries,srid=DEFAULT_SRID,with_z=false,with_m=false)
-        geometry_collection = new(srid,with_z,with_m)
+      # creates a new GeometryCollection from an array of geometries
+      def self.from_geometries(geometries, srid = DEFAULT_SRID, z = false, m = false)
+        geometry_collection = new(srid, z, m)
         geometry_collection.concat(geometries)
         geometry_collection
       end

data/lib/geo_ruby/simple_features/geometry_factory.rb

@@ -1,78 +1,81 @@
-require 'geo_ruby/simple_features/point'
-require 'geo_ruby/simple_features/line_string'
-require 'geo_ruby/simple_features/linear_ring'
-require 'geo_ruby/simple_features/polygon'
-require 'geo_ruby/simple_features/multi_point'
-require 'geo_ruby/simple_features/multi_line_string'
-require 'geo_ruby/simple_features/multi_polygon'
-require 'geo_ruby/simple_features/geometry_collection'
-
-
 module GeoRuby
   module SimpleFeatures
-    #Creates a new geometry according to constructions received from a parser, for example EWKBParser.
+    # Creates a new geometry according to constructions
+    # received from a parser, for example EWKBParser.
     class GeometryFactory
-      #the built geometry
+      # the built geometry
       attr_reader :geometry
 
       def initialize
         @geometry = nil
         @geometry_stack = []
       end
-      #resets the factory
+
+      # resets the factory
       def reset
         @geometry = nil
         @geometry_stack = []
       end
-      #add a 2D point to the current geometry
-      def add_point_x_y(x,y)
-        @geometry_stack.last.set_x_y(x,y)
+
+      # add a 2D point to the current geometry
+      def add_point_x_y(x, y)
+        @geometry_stack.last.set_x_y(x, y)
       end
-      #add 2D points to the current geometry
+
+      # add 2D points to the current geometry
       def add_points_x_y(xy)
-        xy.each_slice(2) {|slice| add_point_x_y(*slice)}
+        xy.each_slice(2) { |slice| add_point_x_y(*slice) }
       end
-      #add a 3D point to the current geometry
-      def add_point_x_y_z(x,y,z)
-        @geometry_stack.last.set_x_y_z(x,y,z)
+
+      # add a 3D point to the current geometry
+      def add_point_x_y_z(x, y, z)
+        @geometry_stack.last.set_x_y_z(x, y, z)
       end
-      #add 3D points to the current geometry
+
+      # add 3D points to the current geometry
       def add_points_x_y_z(xyz)
-        xyz.each_slice(3) {|slice| add_point_x_y_z(*slice)}
+        xyz.each_slice(3) { |slice| add_point_x_y_z(*slice) }
       end
-      #add a 2D point with M to the current geometry
-      def add_point_x_y_m(x,y,m)
-        @geometry_stack.last.set_x_y(x,y)
-        @geometry_stack.last.m=m
+
+      # add a 2D point with M to the current geometry
+      def add_point_x_y_m(x, y, m)
+        @geometry_stack.last.set_x_y(x, y)
+        @geometry_stack.last.m = m
       end
-      #add 2D points with M to the current geometry
+
+      # add 2D points with M to the current geometry
       def add_points_x_y_m(xym)
-        xym.each_slice(3) {|slice| add_point_x_y_m(*slice)}
+        xym.each_slice(3) { |slice| add_point_x_y_m(*slice) }
       end
-      #add a 3D point with M to the current geometry
-      def add_point_x_y_z_m(x,y,z,m)
-        @geometry_stack.last.set_x_y_z(x,y,z)
-        @geometry_stack.last.m=m
+
+      # add a 3D point with M to the current geometry
+      def add_point_x_y_z_m(x, y, z, m)
+        @geometry_stack.last.set_x_y_z(x, y, z)
+        @geometry_stack.last.m = m
       end
-       #add 3D points with M to the current geometry
+
+      # add 3D points with M to the current geometry
       def add_points_x_y_z_m(xyzm)
-        xyzm.each_slice(4) {|slice| add_point_x_y_z_m(*slice)}
+        xyzm.each_slice(4) { |slice| add_point_x_y_z_m(*slice) }
       end
-      #begin a geometry of type +geometry_type+
-      def begin_geometry(geometry_type,srid=DEFAULT_SRID)
-        geometry= geometry_type::new(srid)
-        @geometry= geometry if @geometry.nil?
+
+      # begin a geometry of type +geometry_type+
+      def begin_geometry(geometry_type, srid = DEFAULT_SRID)
+        geometry = geometry_type.new(srid)
+        @geometry = geometry if @geometry.nil?
         @geometry_stack << geometry
       end
-      #terminates the current geometry
-      def end_geometry(with_z=false,with_m=false)
-        @geometry=@geometry_stack.pop
-        @geometry.with_z=with_z
-        @geometry.with_m=with_m
-        #add the newly defined geometry to its parent if there is one
-        @geometry_stack.last << geometry if !@geometry_stack.empty?
+
+      # terminates the current geometry
+      def end_geometry(with_z = false, with_m = false)
+        @geometry = @geometry_stack.pop
+        @geometry.with_z = with_z
+        @geometry.with_m = with_m
+        # add the newly defined geometry to its parent if there is one
+        @geometry_stack.last << geometry unless @geometry_stack.empty?
       end
-      #abort a geometry
+
+      # abort a geometry
       def abort_geometry
         reset
       end

data/lib/geo_ruby/simple_features/helper.rb

@@ -1,18 +1,18 @@
 module GeoRuby
   module SimpleFeatures
-    #indicates the presence of Z coordinates in EWKB strings
-    Z_MASK=0x80000000
-    #indicates the presence of M coordinates in EWKB strings.
-    M_MASK=0x40000000
-    #indicate the presence of a SRID in EWKB strings.
-    SRID_MASK=0x20000000
-    #GeoRSS namespace
-    GEORSS_NS = "http://www.georss.org/georss"
-    #GML Namespace
-    GML_NS = "http://www.opengis.net/gml"
-    #W3CGeo Namespace
-    W3CGEO_NS = "http://www.w3.org/2003/01/geo/wgs84_pos#"
-    #KML Namespace
-    KML_NS = "http://earth.google.com/kml/2.1"
+    # indicates the presence of Z coordinates in EWKB strings
+    Z_MASK = 0x80000000
+    # indicates the presence of M coordinates in EWKB strings.
+    M_MASK = 0x40000000
+    # indicate the presence of a SRID in EWKB strings.
+    SRID_MASK = 0x20000000
+    # GeoRSS namespace
+    GEORSS_NS = 'http://www.georss.org/georss'
+    # GML Namespace
+    GML_NS = 'http://www.opengis.net/gml'
+    # W3CGeo Namespace
+    W3CGEO_NS = 'http://www.w3.org/2003/01/geo/wgs84_pos#'
+    # KML Namespace
+    KML_NS = 'http://earth.google.com/kml/2.1'
   end
 end

data/lib/geo_ruby/simple_features/line_string.rb

@@ -1,44 +1,43 @@
-require "geo_ruby/simple_features/geometry"
+require 'geo_ruby/simple_features/geometry'
 
 module GeoRuby
   module SimpleFeatures
-    #Represents a line string as an array of points (see Point).
+    # Represents a line string as an array of points (see Point).
     class LineString < Geometry
-      #the list of points forming the line string
+      # the list of points forming the line string
       attr_reader :points
 
-      def initialize(srid= DEFAULT_SRID,with_z=false,with_m=false)
-        super(srid,with_z,with_m)
-        @points=[]
+      def initialize(srid = DEFAULT_SRID, with_z = false, with_m = false)
+        super(srid, with_z, with_m)
+        @points = []
       end
 
-      #Delegate the unknown methods to the points array
-      def method_missing(method_name,*args,&b)
-        @points.send(method_name,*args,&b)
+      # Delegate the unknown methods to the points array
+      def method_missing(method_name, *args, &b)
+        @points.send(method_name, *args, &b)
       end
 
-      #tests if the line string is closed
-      def is_closed
-        #a bit naive...
+      # tests if the line string is closed
+      def closed?
+        # a bit naive...
         @points.first == @points.last
       end
-      alias :closed? :is_closed
 
       def clockwise?
         tuples = @points.zip(
           @points[1..-1] + [@points[0]],
           @points[2..-1] + [@points[0], @points[1]])
-        tuples.map!{ |a,b,c| b.x * (c.y - a.y)  }
-        sum = tuples.inject(0.0){ |sum, elem| sum+elem }
-
+        tuples.map! { |a, b, c| b.x * (c.y - a.y)  }
+        sum = tuples.reduce(0.0) { |a, e| a + e }
         sum < 0.0
       end
 
-      #Bounding box in 2D/3D. Returns an array of 2 points
+      # Bounding box in 2D/3D. Returns an array of 2 points
       def bounding_box
-        max_x, min_x, max_y, min_y = -Float::MAX, Float::MAX, -Float::MAX, Float::MAX
-        if(with_z)
-          max_z, min_z = -Float::MAX,Float::MAX
+        max_x = max_y = -Float::MAX
+        min_x = min_y = Float::MAX
+        if with_z
+          max_z, min_z = -Float::MAX, Float::MAX
           each do |point|
             max_y = point.y if point.y > max_y
             min_y = point.y if point.y < min_y
@@ -47,7 +46,7 @@ module GeoRuby
             max_z = point.z if point.z > max_z
             min_z = point.z if point.z < min_z
           end
-          [Point.from_x_y_z(min_x,min_y,min_z),Point.from_x_y_z(max_x,max_y,max_z)]
+          [Point.from_x_y_z(min_x, min_y, min_z), Point.from_x_y_z(max_x, max_y, max_z)]
         else
           each do |point|
             max_y = point.y if point.y > max_y
@@ -55,7 +54,7 @@ module GeoRuby
             max_x = point.x if point.x > max_x
             min_x = point.x if point.x < min_x
           end
-          [Point.from_x_y(min_x,min_y),Point.from_x_y(max_x,max_y)]
+          [Point.from_x_y(min_x, min_y), Point.from_x_y(max_x, max_y)]
         end
       end
 
@@ -66,119 +65,123 @@ module GeoRuby
             max_m = point.m if point.m.to_f > max_m
             min_m = point.m if point.m.to_f < min_m
           end
-          [min_m,max_m]
+          [min_m, max_m]
         else
-          [0,0]
+          [0, 0]
         end
       end
 
-     #call to native Geo intersect, return true or false
-      def intersects?(other_line_string)
-
+      # call to native Geo intersect, return true or false
+      def intersects?(_other_line_string)
       end
 
       def spherical_distance
         total = 0
-        @points.each_with_index do |p,i|
-          total += p.spherical_distance(@points[i+1]) if @points[i+1]
+        @points.each_with_index do |p, i|
+          total += p.spherical_distance(@points[i + 1]) if @points[i + 1]
         end
         total
       end
 
       def euclidian_distance
         total = 0
-        @points.each_with_index do |p,i|
-          total += p.euclidian_distance(@points[i+1]) if @points[i+1]
+        @points.each_with_index do |p, i|
+          total += p.euclidian_distance(@points[i + 1]) if @points[i + 1]
         end
         total
       end
 
-      #Tests the equality of line strings
-      def ==(other_line_string)
-        if(other_line_string.class != self.class or
-             other_line_string.length != self.length)
+      # Tests the equality of line strings
+      def ==(other)
+        if other.class != self.class ||
+           other.length != length
           false
         else
-          index=0
-          while index<length
-            return false if self[index] != other_line_string[index]
-            index+=1
+          index = 0
+          while index < length
+            return false if self[index] != other[index]
+            index += 1
           end
           true
         end
       end
 
-      #Binary representation of a line string
-      def binary_representation(allow_z=true,allow_m=true) #:nodoc:
-        rep = [length].pack("V")
-        each {|point| rep << point.binary_representation(allow_z,allow_m) }
+      # Binary representation of a line string
+      def binary_representation(allow_z = true, allow_m = true) #:nodoc:
+        rep = [length].pack('V')
+        each { |point| rep << point.binary_representation(allow_z, allow_m) }
         rep
       end
 
-      #WKB geometry type
+      # WKB geometry type
       def binary_geometry_type #:nodoc:
         2
       end
 
-      #Text representation of a line string
-      def text_representation(allow_z=true,allow_m=true) #:nodoc:
-        @points.collect{|point| point.text_representation(allow_z,allow_m) }.join(",")
+      # Text representation of a line string
+      def text_representation(allow_z = true, allow_m = true) #:nodoc:
+        @points.collect { |point| point.text_representation(allow_z, allow_m) }.join(',')
       end
-      #WKT geometry type
+      # WKT geometry type
       def text_geometry_type #:nodoc:
-        "LINESTRING"
+        'LINESTRING'
       end
 
-      #georss simple representation
+      # georss simple representation
       def georss_simple_representation(options) #:nodoc:
-        georss_ns = options[:georss_ns] || "georss"
+        georss_ns = options[:georss_ns] || 'georss'
         geom_attr = options[:geom_attr]
-        "<#{georss_ns}:line#{geom_attr}>" + georss_poslist + "</#{georss_ns}:line>\n"
+        "<#{georss_ns}:line#{geom_attr}>#{georss_poslist}</#{georss_ns}:line>\n"
       end
-      #georss w3c representation : outputs the first point of the line
+
+      # georss w3c representation : outputs the first point of the line
       def georss_w3cgeo_representation(options) #:nodoc:
-        w3cgeo_ns = options[:w3cgeo_ns] || "geo"
-        "<#{w3cgeo_ns}:lat>#{self[0].y}</#{w3cgeo_ns}:lat>\n<#{w3cgeo_ns}:long>#{self[0].x}</#{w3cgeo_ns}:long>\n"
+        w3cgeo_ns = options[:w3cgeo_ns] || 'geo'
+        "<#{w3cgeo_ns}:lat>#{self[0].y}</#{w3cgeo_ns}:lat>\n"\
+        "<#{w3cgeo_ns}:long>#{self[0].x}</#{w3cgeo_ns}:long>\n"
       end
-      #georss gml representation
+
+      # georss gml representation
       def georss_gml_representation(options) #:nodoc:
-        georss_ns = options[:georss_ns] || "georss"
-        gml_ns = options[:gml_ns] || "gml"
+        georss_ns = options[:georss_ns] || 'georss'
+        gml_ns = options[:gml_ns] || 'gml'
 
-        result = "<#{georss_ns}:where>\n<#{gml_ns}:LineString>\n<#{gml_ns}:posList>\n"
-        result += georss_poslist
-        result += "\n</#{gml_ns}:posList>\n</#{gml_ns}:LineString>\n</#{georss_ns}:where>\n"
+        "<#{georss_ns}:where>\n<#{gml_ns}:LineString>\n<#{gml_ns}:posList>\n" \
+        "#{georss_poslist}\n</#{gml_ns}:posList>\n</#{gml_ns}:LineString>\n" \
+        "</#{georss_ns}:where>\n"
       end
 
       def georss_poslist #:nodoc:
-        map {|point| "#{point.y} #{point.x}"}.join(" ")
+        map { |point| "#{point.y} #{point.x}" }.join(' ')
       end
 
-      #outputs the geometry in kml format : options are <tt>:id</tt>, <tt>:tesselate</tt>, <tt>:extrude</tt>,
-      #<tt>:altitude_mode</tt>. If the altitude_mode option is not present, the Z (if present) will not be output (since
-      #it won't be used by GE anyway: clampToGround is the default)
+      # outputs the geometry in kml format : options are <tt>:id</tt>,
+      # <tt>:tesselate</tt>, <tt>:extrude</tt>, <tt>:altitude_mode</tt>.
+      # If the altitude_mode option is not present, the Z (if present) will not
+      # be output (since it won't be used by GE: clampToGround is the default)
       def kml_representation(options = {}) #:nodoc:
         result = "<LineString#{options[:id_attr]}>\n"
         result += options[:geom_data] if options[:geom_data]
-        result += "<coordinates>"
+        result += '<coordinates>'
         result += kml_poslist(options)
         result += "</coordinates>\n"
-        result += "</LineString>\n"
+        result + "</LineString>\n"
       end
 
       def kml_poslist(options) #:nodoc:
-        pos_list = if options[:allow_z]
-           map {|point| "#{point.x},#{point.y},#{options[:fixed_z] || point.z || 0}" }
+        pos_list = \
+        if options[:allow_z]
+          map { |point| "#{point.x},#{point.y},#{options[:fixed_z] || point.z || 0}" }
         else
-          map {|point| "#{point.x},#{point.y}" }
+          map { |point| "#{point.x},#{point.y}" }
         end
-        pos_list.reverse! if(options[:reverse])
-        pos_list.join(" ")
+        pos_list.reverse! if options[:reverse]
+        pos_list.join(' ')
       end
 
       # Simplify linestring (Douglas Peucker Algorithm)
       # http://en.wikipedia.org/wiki/Ramer-Douglas-Peucker_algorithm
-      def simplify(epsilon=1)
+      def simplify(epsilon = 1)
         LineString.from_points(do_simplify(@points, epsilon))
       end
 
@@ -188,40 +191,34 @@ module GeoRuby
           d = list[i].orthogonal_distance(list[0], list[-1])
           index, dmax = i, d if d > dmax
         end
-
-        if dmax >= epsilon
-          res1 = do_simplify(list[0..index], epsilon)
-          res2 = do_simplify(list[index..-1], epsilon)
-          res1[0..-2] + res2[0..-1]
-        else
-          [list[0], list[-1]]
-        end
+        return [list[0], list[-1]] if dmax < epsilon
+        res1 = do_simplify(list[0..index], epsilon)
+        res2 = do_simplify(list[index..-1], epsilon)
+        res1[0..-2] + res2[0..-1]
       end
 
       def to_coordinates
-        points.map { |p| p.to_coordinates }
+        points.map(&:to_coordinates)
       end
 
-      def as_json(options = {})
-        {:type => 'LineString', :coordinates => self.to_coordinates}
+      def as_json(_options = {})
+        { type: 'LineString', coordinates: to_coordinates }
       end
 
-      #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)
+      # Creates a new line string. Accept an array of points as argument
+      def self.from_points(points, srid = DEFAULT_SRID, z = false, m = false)
+        line_string = new(srid, z, m)
         line_string.concat(points)
         line_string
       end
 
-      #Creates a new line string. Accept a sequence of points as argument : ((x,y)...(x,y))
-      def self.from_coordinates(points,srid=DEFAULT_SRID,with_z=false,with_m=false)
-        line_string = new(srid,with_z,with_m)
-        line_string.concat( points.map {|p| Point.from_coordinates(p,srid,with_z,with_m) } )
+      # Creates a new line string. Accept a sequence of points as argument:
+      #  ((x,y)...(x,y))
+      def self.from_coordinates(points, srid = DEFAULT_SRID, z = false, m = false)
+        line_string = new(srid, z, m)
+        line_string.concat(points.map { |p| Point.from_coordinates(p, srid, z, m) })
         line_string
       end
-
-    end #LineString
-
-  end #SimpleFeatures
-
-end #GeoRuby
+    end # LineString
+  end # SimpleFeatures
+end # GeoRuby