georuby 2.3.0 → 2.5.1

data/lib/geo_ruby/simple_features/linear_ring.rb

@@ -1,15 +1,12 @@
 require 'geo_ruby/simple_features/line_string'
 
 module GeoRuby
-
   module SimpleFeatures
-
-    #Represents a linear ring, which is a closed line string (see LineString).
-    #Currently, no check is performed to verify if the linear ring is really closed.
+    # Represents a linear ring, which is a closed line string (see LineString).
+    # Currently, no check is performed to verify if the linear ring is really closed.
     class LinearRing < LineString
-
-      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)
       end
 
       # fix kml export
@@ -33,7 +30,5 @@ module GeoRuby
         crossings.size % 2 == 1
       end
     end
-
   end
-
 end

data/lib/geo_ruby/simple_features/multi_line_string.rb

@@ -1,13 +1,10 @@
 require 'geo_ruby/simple_features/geometry_collection'
 
 module GeoRuby
-
   module SimpleFeatures
-
-    #Represents a group of line strings (see LineString).
+    # Represents a group of line strings (see LineString).
     class MultiLineString < GeometryCollection
-
-      def initialize(srid = DEFAULT_SRID,with_z=false,with_m=false)
+      def initialize(srid = DEFAULT_SRID, _with_z = false, _with_m = false)
         super(srid)
       end
 
@@ -19,39 +16,39 @@ module GeoRuby
         geometries.map(&:points).flatten
       end
 
-      #Text representation of a multi line string
-      def text_representation(allow_z=true,allow_m=true) #:nodoc:
-        @geometries.collect{|line_string| "(" + line_string.text_representation(allow_z,allow_m) + ")" }.join(",")
+      # Text representation of a multi line string
+      def text_representation(allow_z = true, allow_m = true) #:nodoc:
+        @geometries.collect { |line_string| '(' + line_string.text_representation(allow_z, allow_m) + ')' }.join(',')
       end
 
-      #WKT geometry type
+      # WKT geometry type
       def text_geometry_type #:nodoc:
-        "MULTILINESTRING"
+        'MULTILINESTRING'
       end
 
-      def to_line_string(join = true)
+      def to_line_string(_join = true)
         LineString.from_points(points)
       end
 
       def to_coordinates
-        geometries.map{|ls| ls.to_coordinates}
+        geometries.map(&:to_coordinates)
       end
 
-      def as_json(options = {})
-        {:type => 'MultiLineString', :coordinates => self.to_coordinates}
+      def as_json(_options = {})
+        { type: 'MultiLineString', coordinates: to_coordinates }
       end
 
-      #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)
+      # 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)
         multi_line_string.concat(line_strings)
         multi_line_string
       end
 
-      #Creates a new multi line string from sequences of points : (((x,y)...(x,y)),((x,y)...(x,y)))
-      def self.from_coordinates(point_sequences,srid=DEFAULT_SRID,with_z=false,with_m=false)
-        multi_line_string = new(srid,with_z,with_m)
-        multi_line_string.concat(point_sequences.collect {|points| LineString.from_coordinates(points,srid,with_z,with_m) })
+      # Creates a new multi line string from sequences of points : (((x,y)...(x,y)),((x,y)...(x,y)))
+      def self.from_coordinates(point_sequences, srid = DEFAULT_SRID, with_z = false, with_m = false)
+        multi_line_string = new(srid, with_z, with_m)
+        multi_line_string.concat(point_sequences.collect { |points| LineString.from_coordinates(points, srid, with_z, with_m) })
         multi_line_string
       end
     end

data/lib/geo_ruby/simple_features/multi_point.rb

@@ -2,11 +2,10 @@ require 'geo_ruby/simple_features/geometry_collection'
 
 module GeoRuby
   module SimpleFeatures
-    #Represents a group of points (see Point).
+    # Represents a group of points (see Point).
     class MultiPoint < GeometryCollection
-
-      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)
       end
 
       def binary_geometry_type #:nodoc:
@@ -17,38 +16,37 @@ module GeoRuby
         @geometries
       end
 
-      #Text representation of a MultiPoint
-      def text_representation(allow_z=true,allow_m=true) #:nodoc:
-        "(" + @geometries.collect{|point| point.text_representation(allow_z,allow_m)}.join("),(") + ")"
+      # Text representation of a MultiPoint
+      def text_representation(allow_z = true, allow_m = true) #:nodoc:
+        '(' + @geometries.collect { |point| point.text_representation(allow_z, allow_m) }.join('),(') + ')'
       end
 
-      #WKT geoemtry type
+      # WKT geoemtry type
       def text_geometry_type #:nodoc:
-        "MULTIPOINT"
+        'MULTIPOINT'
       end
 
       def to_coordinates
-        points.map{|p| p.to_coordinates }
+        points.map(&:to_coordinates)
       end
 
-      def as_json(options = {})
-        {:type => 'MultiPoint', :coordinates => self.to_coordinates}
+      def as_json(_options = {})
+        { type: 'MultiPoint', coordinates: to_coordinates }
       end
 
-      #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)
+      # 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)
         multi_point.concat(points)
         multi_point
       end
 
-      #Creates a new multi point from a list of point coordinates : ((x,y)...(x,y))
-      def self.from_coordinates(points,srid= DEFAULT_SRID,with_z=false,with_m=false)
-        multi_point= new(srid,with_z,with_m)
-        multi_point.concat(points.collect {|point| Point.from_coordinates(point,srid,with_z,with_m)})
+      # Creates a new multi point from a list of point coordinates : ((x,y)...(x,y))
+      def self.from_coordinates(points, srid = DEFAULT_SRID, with_z = false, with_m = false)
+        multi_point = new(srid, with_z, with_m)
+        multi_point.concat(points.collect { |point| Point.from_coordinates(point, srid, with_z, with_m) })
         multi_point
       end
-
     end
   end
 end

data/lib/geo_ruby/simple_features/multi_polygon.rb

@@ -1,13 +1,10 @@
 require 'geo_ruby/simple_features/geometry_collection'
 
 module GeoRuby
-
   module SimpleFeatures
-
-    #Represents a group of polygons (see Polygon).
+    # Represents a group of polygons (see Polygon).
     class MultiPolygon < GeometryCollection
-
-      def initialize(srid = DEFAULT_SRID,with_z=false,with_m=false)
+      def initialize(srid = DEFAULT_SRID, _with_z = false, _with_m = false)
         super(srid)
       end
 
@@ -16,46 +13,43 @@ module GeoRuby
       end
 
       def points
-        @points ||= geometries.inject([]) do |arr, r|
+        @points ||= geometries.reduce([]) do |arr, r|
           arr.concat(r.rings.map(&:points).flatten)
         end
       end
 
-      #Text representation of a MultiPolygon
-      def text_representation(allow_z=true,allow_m=true) #:nodoc:
-        @geometries.map {|polygon| "(" + polygon.text_representation(allow_z,allow_m) + ")"}.join(",")
+      # Text representation of a MultiPolygon
+      def text_representation(allow_z = true, allow_m = true) #:nodoc:
+        @geometries.map { |polygon| '(' + polygon.text_representation(allow_z, allow_m) + ')' }.join(',')
       end
 
-      #WKT geometry type
+      # WKT geometry type
       def text_geometry_type #:nodoc:
-        "MULTIPOLYGON"
+        'MULTIPOLYGON'
       end
 
       def to_coordinates
-        geometries.map{|polygon| polygon.to_coordinates}
+        geometries.map(&:to_coordinates)
       end
 
-      def as_json(options = {})
-        {:type => 'MultiPolygon',
-         :coordinates => self.to_coordinates}
+      def as_json(_options = {})
+        { type: 'MultiPolygon',
+          coordinates: to_coordinates }
       end
 
-      #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)
+      # 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)
         multi_polygon.concat(polygons)
         multi_polygon
       end
 
-      #Creates a multi polygon from sequences of points : ((((x,y)...(x,y)),((x,y)...(x,y)),((x,y)...(x,y)))
-      def self.from_coordinates(point_sequence_sequences,srid= DEFAULT_SRID,with_z=false,with_m=false)
-        multi_polygon = new(srid,with_z,with_m)
-        multi_polygon.concat( point_sequence_sequences.collect {|point_sequences| Polygon.from_coordinates(point_sequences,srid,with_z,with_m) } )
+      # Creates a multi polygon from sequences of points : ((((x,y)...(x,y)),((x,y)...(x,y)),((x,y)...(x,y)))
+      def self.from_coordinates(point_sequence_sequences, srid = DEFAULT_SRID, with_z = false, with_m = false)
+        multi_polygon = new(srid, with_z, with_m)
+        multi_polygon.concat(point_sequence_sequences.collect { |point_sequences| Polygon.from_coordinates(point_sequences, srid, with_z, with_m) })
         multi_polygon
       end
-
     end
-
   end
-
 end

data/lib/geo_ruby/simple_features/point.rb

@@ -7,23 +7,23 @@ module GeoRuby
     class Point < Geometry
       DEG2RAD = 0.0174532925199433
       HALFPI  = 1.5707963267948966
-      attr_accessor :x,:y,:z,:m
+      attr_accessor :x, :y, :z, :m
       attr_reader :r, :t # radium and theta
 
       # If you prefer calling the coordinates lat and lon
       # (or lng, for GeoKit compatibility)
-      alias :lon :x
-      alias :lng :x
-      alias :lat :y
-      alias :rad :r
-      alias :tet :t
-      alias :tetha :t
+      alias_method :lon, :x
+      alias_method :lng, :x
+      alias_method :lat, :y
+      alias_method :rad, :r
+      alias_method :tet, :t
+      alias_method :tetha, :t
 
       def initialize(srid = DEFAULT_SRID, with_z = false, with_m = false)
         super(srid, with_z, with_m)
         @x = @y = 0.0
-        @z = 0.0 #default value : meaningful if with_z
-        @m = 0.0 #default value : meaningful if with_m
+        @z = 0.0 # default value : meaningful if with_z
+        @m = 0.0 # default value : meaningful if with_m
       end
 
       # Sets all coordinates in one call.
@@ -34,7 +34,7 @@ module GeoRuby
         @z = z && !z.is_a?(Numeric) ? z.to_f : z
         self
       end
-      alias :set_lon_lat_z :set_x_y_z
+      alias_method :set_lon_lat_z, :set_x_y_z
 
       # Sets all coordinates of a 2D point in one call
       def set_x_y(x, y)
@@ -42,7 +42,7 @@ module GeoRuby
         @y = y && !y.is_a?(Numeric) ? y.to_f : y
         self
       end
-      alias :set_lon_lat :set_x_y
+      alias_method :set_lon_lat, :set_x_y
 
       # Return the distance between the 2D points (ie taking care only
       # of the x and y coordinates), assuming the points are in
@@ -58,72 +58,79 @@ module GeoRuby
       # Assumes x is the lon and y the lat, in degrees.
       # The user has to make sure using this distance makes sense
       # (ie she should be in latlon coordinates)
-      def spherical_distance(point, r = 6370997.0)
+      def spherical_distance(point, r = 6_370_997.0)
         dlat = (point.lat - lat) * DEG2RAD / 2
         dlon = (point.lon - lon) * DEG2RAD / 2
 
         a = Math.sin(dlat)**2 + Math.cos(lat * DEG2RAD) *
-          Math.cos(point.lat * DEG2RAD) * Math.sin(dlon)**2
-        c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a))
+            Math.cos(point.lat * DEG2RAD) * Math.sin(dlon)**2
+        c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1 - a))
         r * c
       end
 
-      # Ellipsoidal distance in m using Vincenty's formula. Lifted entirely from Chris Veness's code at http://www.movable-type.co.uk/scripts/LatLongVincenty.html and adapted for Ruby. Assumes the x and y are the lon and lat in degrees.
+      #
+      # Ellipsoidal distance in m using Vincenty's formula.
+      # Lifted entirely from Chris Veness's code at
+      # http://www.movable-type.co.uk/scripts/LatLongVincenty.html
+      # and adapted for Ruby.
+      #
+      # Assumes the x and y are the lon and lat in degrees.
       # a is the semi-major axis (equatorial radius) of the ellipsoid
       # b is the semi-minor axis (polar radius) of the ellipsoid
-      # Their values by default are set to the ones of the WGS84 ellipsoid
-      def ellipsoidal_distance(point, a = 6378137.0, b = 6356752.3142)
+      # Their values by default are set to the WGS84 ellipsoid.
+      #
+      def ellipsoidal_distance(point, a = 6_378_137.0, b = 6_356_752.3142)
         f = (a - b) / a
         l = (point.lon - lon) * DEG2RAD
 
-        u1 = Math.atan((1-f) * Math.tan(lat * DEG2RAD ))
-        u2 = Math.atan((1-f) * Math.tan(point.lat * DEG2RAD))
-        sinU1 = Math.sin(u1)
-        cosU1 = Math.cos(u1)
-        sinU2 = Math.sin(u2)
-        cosU2 = Math.cos(u2)
+        u1 = Math.atan((1 - f) * Math.tan(lat * DEG2RAD))
+        u2 = Math.atan((1 - f) * Math.tan(point.lat * DEG2RAD))
+        sin_u1 = Math.sin(u1)
+        cos_u1 = Math.cos(u1)
+        sin_u2 = Math.sin(u2)
+        cos_u2 = Math.cos(u2)
 
         lambda = l
-        lambdaP = 2 * Math::PI
-        iterLimit = 20
-
-        while (lambda - lambdaP).abs > 1e-12 && --iterLimit > 0
-          sinLambda = Math.sin(lambda)
-          cosLambda = Math.cos(lambda)
-          sinSigma  =\
-          Math.sqrt((cosU2 * sinLambda) * (cosU2 * sinLambda) +
-                    (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda) *
-                    (cosU1 * sinU2 - sinU1 * cosU2 * cosLambda))
-
-          return 0 if sinSigma == 0 # coincident points
-
-          cosSigma   = sinU1 * sinU2 + cosU1 * cosU2 * cosLambda
-          sigma      = Math.atan2(sinSigma, cosSigma)
-          sinAlpha   = cosU1 * cosU2 * sinLambda / sinSigma
-          cosSqAlpha = 1 - sinAlpha * sinAlpha
-          cos2SigmaM = cosSigma - 2 * sinU1 * sinU2 / cosSqAlpha
-
-          # equatorial line: cosSqAlpha=0
-          cos2SigmaM = 0 if (cos2SigmaM.nan?)
-
-          c = f / 16 * cosSqAlpha * (4 + f * (4 - 3 * cosSqAlpha))
-          lambdaP = lambda
-          lambda = l + (1 - c) * f * sinAlpha * (sigma + c * sinSigma *
-            (cos2SigmaM + c * cosSigma * (-1 + 2 * cos2SigmaM *
-                cos2SigmaM)))
+        lambda_p = 2 * Math::PI
+        iter_limit = 20
+
+        while (lambda - lambda_p).abs > 1e-12 && --iter_limit > 0
+          sin_lambda = Math.sin(lambda)
+          cos_lambda = Math.cos(lambda)
+          sin_sigma = \
+          Math.sqrt((cos_u2 * sin_lambda) * (cos_u2 * sin_lambda) +
+                    (cos_u1 * sin_u2 - sin_u1 * cos_u2 * cos_lambda) *
+                    (cos_u1 * sin_u2 - sin_u1 * cos_u2 * cos_lambda))
+
+          return 0 if sin_sigma == 0 # coincident points
+
+          cos_sigma   = sin_u1 * sin_u2 + cos_u1 * cos_u2 * cos_lambda
+          sigma      = Math.atan2(sin_sigma, cos_sigma)
+          sin_alpha   = cos_u1 * cos_u2 * sin_lambda / sin_sigma
+          cos_sq_alpha = 1 - sin_alpha * sin_alpha
+          cos2_sigma_m = cos_sigma - 2 * sin_u1 * sin_u2 / cos_sq_alpha
+
+          # equatorial line: cos_sq_alpha=0
+          cos2_sigma_m = 0 if cos2_sigma_m.nan?
+
+          c = f / 16 * cos_sq_alpha * (4 + f * (4 - 3 * cos_sq_alpha))
+          lambda_p = lambda
+          lambda = l + (1 - c) * f * sin_alpha * (sigma + c * sin_sigma *
+            (cos2_sigma_m + c * cos_sigma * (-1 + 2 * cos2_sigma_m *
+                cos2_sigma_m)))
         end
 
-        return NaN if iterLimit==0 #formula failed to converge
+        return NaN if iter_limit == 0 # formula failed to converge
 
-        uSq = cosSqAlpha * (a*a - b*b) / (b*b)
-        a_bis = 1 + uSq/16384*(4096+uSq*(-768+uSq*(320-175*uSq)))
-        b_bis = uSq/1024 * (256+uSq*(-128 + uSq * (74 - 47 * uSq)))
-        deltaSigma = b_bis * sinSigma * (cos2SigmaM + b_bis / 4 *
-          (cosSigma * (-1 + 2 * cos2SigmaM * cos2SigmaM) - b_bis / 6 *
-            cos2SigmaM * (-3 + 4 * sinSigma * sinSigma) * (-3 + 4 *
-              cos2SigmaM * cos2SigmaM)))
+        usq = cos_sq_alpha * (a * a - b * b) / (b * b)
+        a_bis = 1 + usq / 16_384 * (4096 + usq * (-768 + usq * (320 - 175 * usq)))
+        b_bis = usq / 1024 * (256 + usq * (-128 + usq * (74 - 47 * usq)))
+        delta_sigma = b_bis * sin_sigma * (cos2_sigma_m + b_bis / 4 *
+          (cos_sigma * (-1 + 2 * cos2_sigma_m * cos2_sigma_m) - b_bis / 6 *
+            cos2_sigma_m * (-3 + 4 * sin_sigma * sin_sigma) * (-3 + 4 *
+              cos2_sigma_m * cos2_sigma_m)))
 
-        b * a_bis * (sigma - deltaSigma)
+        b * a_bis * (sigma - delta_sigma)
       end
 
       # Orthogonal Distance
@@ -138,7 +145,7 @@ module GeoRuby
         return 0.0 if len.zero?
         res = dot / len
 
-        xx, yy =\
+        xx, yy = \
         if res < 0
           [head.x, head.y]
         elsif res > 1
@@ -146,16 +153,16 @@ module GeoRuby
         else
           [head.x + res * c, head.y + res * d]
         end
-        # todo benchmark if worth creating an instance
+        # TODO: benchmark if worth creating an instance
         # euclidian_distance(Point.from_x_y(xx, yy))
-        Math.sqrt((@x - xx) ** 2 + (@y - yy) ** 2)
+        Math.sqrt((@x - xx)**2 + (@y - yy)**2)
       end
 
       # Bearing from a point to another, in degrees.
       def bearing_to(other)
         return 0 if self == other
-        a,b =  other.x - self.x, other.y - self.y
-        res =  Math.acos(b / Math.sqrt(a*a+b*b)) / Math::PI * 180;
+        a, b =  other.x - x, other.y - y
+        res =  Math.acos(b / Math.sqrt(a * a + b * b)) / Math::PI * 180
         a < 0 ? 360 - res : res
       end
 
@@ -178,37 +185,38 @@ module GeoRuby
       # Bounding box in 2D/3D. Returns an array of 2 points
       def bounding_box
         if with_z
-          [Point.from_x_y_z(@x,@y,@z),Point.from_x_y_z(@x,@y,@z)]
+          [Point.from_x_y_z(@x, @y, @z), Point.from_x_y_z(@x, @y, @z)]
         else
-          [Point.from_x_y(@x,@y),Point.from_x_y(@x,@y)]
+          [Point.from_x_y(@x, @y), Point.from_x_y(@x, @y)]
         end
       end
 
       def m_range
-        [@m,@m]
+        [@m, @m]
       end
 
       # Tests the equality of the position of points + m
       def ==(other)
-        return false unless other.kind_of?(Point)
+        return false unless other.is_a?(Point)
         @x == other.x && @y == other.y && @z == other.z && @m == other.m
       end
 
-      # Binary representation of a point. It lacks some headers to be a valid EWKB representation.
-      def binary_representation(allow_z=true,allow_m=true) #:nodoc:
-        bin_rep = [@x.to_f,@y.to_f].pack('EE')
-        bin_rep += [@z.to_f].pack('E') if @with_z && allow_z #Default value so no crash
-        bin_rep += [@m.to_f].pack('E') if @with_m && allow_m #idem
+      # Binary representation of a point.
+      # It lacks some headers to be a valid EWKB representation.
+      def binary_representation(allow_z = true, allow_m = true) #:nodoc:
+        bin_rep = [@x.to_f, @y.to_f].pack('EE')
+        bin_rep += [@z.to_f].pack('E') if @with_z && allow_z # Default value so no crash
+        bin_rep += [@m.to_f].pack('E') if @with_m && allow_m # idem
         bin_rep
       end
 
       # WKB geometry type of a point
-      def binary_geometry_type#:nodoc:
+      def binary_geometry_type #:nodoc:
         1
       end
 
       # Text representation of a point
-      def text_representation(allow_z=true,allow_m=true) #:nodoc:
+      def text_representation(allow_z = true, allow_m = true) #:nodoc:
         tex_rep = "#{@x} #{@y}"
         tex_rep += " #{@z}" if @with_z && allow_z
         tex_rep += " #{@m}" if @with_m && allow_m
@@ -222,24 +230,23 @@ module GeoRuby
 
       # 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}:point#{geom_attr}>#{y} #{x}</#{georss_ns}:point>\n"
       end
 
       # georss w3c representation
       def georss_w3cgeo_representation(options) #:nodoc:
-        w3cgeo_ns = options[:w3cgeo_ns] || "geo"
+        w3cgeo_ns = options[:w3cgeo_ns] || 'geo'
         "<#{w3cgeo_ns}:lat>#{y}</#{w3cgeo_ns}:lat>\n<#{w3cgeo_ns}:long>#{x}</#{w3cgeo_ns}:long>\n"
       end
 
       # georss gml representation
       def georss_gml_representation(options) #:nodoc:
-        georss_ns = options[:georss_ns] || "georss"
-        gml_ns = options[:gml_ns] || "gml"
-        out = "<#{georss_ns}:where>\n<#{gml_ns}:Point>\n<#{gml_ns}:pos>"
-        out += "#{y} #{x}"
-        out += "</#{gml_ns}:pos>\n</#{gml_ns}:Point>\n</#{georss_ns}:where>\n"
+        georss_ns = options[:georss_ns] || 'georss'
+        gml_ns = options[:gml_ns] || 'gml'
+        "<#{georss_ns}:where>\n<#{gml_ns}:Point>\n<#{gml_ns}:pos>#{y} #{x}" \
+        "</#{gml_ns}:pos>\n</#{gml_ns}:Point>\n</#{georss_ns}:where>\n"
       end
 
       # outputs the geometry in kml format : options are
@@ -252,9 +259,9 @@ module GeoRuby
         out = "<Point#{options[:id_attr]}>\n"
         out += options[:geom_data] if options[:geom_data]
         out += "<coordinates>#{x},#{y}"
-        out += ",#{options[:fixed_z] || z ||0}" if options[:allow_z]
+        out += ",#{options[:fixed_z] || z || 0}" if options[:allow_z]
         out += "</coordinates>\n"
-        out += "</Point>\n"
+        out + "</Point>\n"
       end
 
       def html_representation(options = {})
@@ -262,23 +269,25 @@ module GeoRuby
         out =  '<span class=\'geo\'>'
         out += "<abbr class='latitude' title='#{x}'>#{as_lat(options)}</abbr>"
         out += "<abbr class='longitude' title='#{y}'>#{as_long(options)}</abbr>"
-        out += '</span>'
+        out + '</span>'
       end
 
       # Human representation of the geom, don't use directly, use:
       # #as_lat, #as_long, #as_latlong
-      def human_representation(options = { }, g = { :x => x, :y => y })
+      def human_representation(options = {}, g = { x: x, y: y })
         g.map do |k, v|
           deg = v.to_i.abs
           min = (60 * (v.abs - deg)).to_i
           labs = (v * 1_000_000).abs / 1_000_000
-          sec = ((((labs - labs.to_i) * 60) - ((labs - labs.to_i) * 60).to_i) * 100_000) * 60 / 100_000
-          str = options[:full] ? "%.i°%.2i′%05.2f″" :  "%.i°%.2i′%02.0f″"
+          sec = ((((labs - labs.to_i) * 60) -
+              ((labs - labs.to_i) * 60).to_i) * 100_000) * 60 / 100_000
+          str = options[:full] ? '%.i°%.2i′%05.2f″' :  '%.i°%.2i′%02.0f″'
           if options[:coord]
-            out = str % [deg,min,sec]
-            out += k == :x ? v > 0 ? 'N' : 'S' : v > 0 ? 'E' : 'W'
+            out = format(str, deg, min, sec)
+            # Add cardinal
+            out + (k == :x ? v > 0 ? 'N' : 'S' : v > 0 ? 'E' : 'W')
           else
-            str % [v.to_i, min, sec]
+            format(str, v.to_i, min, sec)
           end
         end
       end
@@ -286,22 +295,22 @@ module GeoRuby
       # Outputs the geometry coordinate in human format:
       # 47°52′48″N
       def as_lat(options = {})
-        human_representation(options, { x: x }).join
+        human_representation(options, x: x).join
       end
 
       # Outputs the geometry coordinate in human format:
       # -20°06′00W″
       def as_long(options = {})
-        human_representation(options, { y: y }).join
+        human_representation(options, y: y).join
       end
-      alias :as_lng :as_long
+      alias_method :as_lng, :as_long
 
       # Outputs the geometry in coordinates format:
       # 47°52′48″, -20°06′00″
       def as_latlong(options = {})
         human_representation(options).join(', ')
       end
-      alias :as_ll :as_latlong
+      alias_method :as_ll, :as_latlong
 
       # Polar stuff
       #
@@ -317,8 +326,8 @@ module GeoRuby
         if @x.zero?
           @y < 0 ? 3 * HALFPI : HALFPI
         else
-          th = Math.atan(@y/@x)
-          th += 2 * Math::PI if r > 0
+          th = Math.atan(@y / @x)
+          r > 0 ? th + 2 * Math::PI : th
         end
       end
 
@@ -333,8 +342,8 @@ module GeoRuby
       end
 
       # Outputs the point in json format
-      def as_json(options = {})
-        {:type => 'Point', :coordinates => self.to_coordinates }
+      def as_json(_options = {})
+        { type: 'Point', coordinates: to_coordinates }
       end
 
       # Invert signal of all coordinates
@@ -342,13 +351,12 @@ module GeoRuby
         set_x_y_z(-@x, -@y, -@z)
       end
 
-      # TODO Perhaps should support with_m analogous to from_coordinates?
+      # Helper to get all coordinates as array.
       def to_coordinates
-        if with_z
-          [x, y, z]
-        else
-          [x, y]
-        end
+        coord = [x, y]
+        coord << z if with_z
+        coord << m if with_m
+        coord
       end
 
       # Simple helper for 2D maps
@@ -362,12 +370,12 @@ module GeoRuby
       end
 
       # 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)
+      def self.from_coordinates(coords, srid = DEFAULT_SRID, z = false, m = false)
+        if !(z || m)
           from_x_y(coords[0], coords[1], srid)
-        elsif with_z && with_m
+        elsif z && m
           from_x_y_z_m(coords[0], coords[1], coords[2], coords[3], srid)
-        elsif with_z
+        elsif z
           from_x_y_z(coords[0], coords[1], coords[2], srid)
         else
           from_x_y_m(coords[0], coords[1], coords[2], srid)
@@ -413,7 +421,8 @@ module GeoRuby
       # Creates a point using coordinates like 22`34 23.45N
       def self.from_latlong(lat, lon, srid = DEFAULT_SRID)
         p = [lat, lon].map do |l|
-          sig, deg, min, sec, cen = l.scan(/(-)?(\d{1,2})\D*(\d{2})\D*(\d{2})(\D*(\d{1,3}))?/).flatten
+          sig, deg, min, sec, cen = \
+          l.scan(/(-)?(\d{1,2})\D*(\d{2})\D*(\d{2})(\D*(\d{1,3}))?/).flatten
           sig = true if l =~ /W|S/
           dec = deg.to_i + (min.to_i * 60 + "#{sec}#{cen}".to_f) / 3600
           sig ? dec * -1 : dec
@@ -422,22 +431,19 @@ module GeoRuby
         point.set_x_y(p[0], p[1])
       end
 
-      # Aliasing the constructors in case you like lat/lon instead of y/x
+      # Aliasing the constructors in case you like lat/lon over y/x
       class << self
-        alias :xy               :from_x_y
-        alias :from_xy          :from_x_y
-        alias :xyz              :from_x_y_z
-        alias :from_xyz         :from_x_y_z
-        alias :from_lon_lat_z   :from_x_y_z
-        alias :from_lon_lat     :from_x_y
-        alias :from_lon_lat_z   :from_x_y_z
-        alias :from_lon_lat_m   :from_x_y_m
-        alias :from_lon_lat_z_m :from_x_y_z_m
-        alias :from_rad_tet     :from_r_t
-      end
-
-    end #Point
-
-  end #SimpleFeatures
-
-end #GeoRuby
+        alias_method :xy,               :from_x_y
+        alias_method :from_xy,          :from_x_y
+        alias_method :xyz,              :from_x_y_z
+        alias_method :from_xyz,         :from_x_y_z
+        alias_method :from_lon_lat_z,   :from_x_y_z
+        alias_method :from_lon_lat,     :from_x_y
+        alias_method :from_lon_lat_z,   :from_x_y_z
+        alias_method :from_lon_lat_m,   :from_x_y_m
+        alias_method :from_lon_lat_z_m, :from_x_y_z_m
+        alias_method :from_rad_tet,     :from_r_t
+      end
+    end # Point
+  end # SimpleFeatures
+end # GeoRuby