rgeo 0.4.0 → 0.5.0

data/lib/rgeo/wkrep/wkb_parser.rb

@@ -5,10 +5,7 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module WKRep
-
-
     # This class provides the functionality of parsing a geometry from
     # WKB (well-known binary) format. You may also customize the parser
     # to recognize PostGIS EWKB extensions to the input, or Simple
@@ -45,13 +42,11 @@ module RGeo
     #   the input. Defaults to nil (i.e. don't specify a SRID).
 
     class WKBParser
-
-
       # Create and configure a WKB parser. See the WKBParser
       # documentation for the options that can be passed.
 
-      def initialize(factory_generator_=nil, opts_={})
-        if factory_generator_.kind_of?(Feature::Factory::Instance)
+      def initialize(factory_generator_ = nil, opts_ = {})
+        if factory_generator_.is_a?(Feature::Factory::Instance)
           @factory_generator = Feature::FactoryGenerator.single(factory_generator_)
           @exact_factory = factory_generator_
         elsif factory_generator_.respond_to?(:call)
@@ -67,17 +62,12 @@ module RGeo
         @default_srid = opts_[:default_srid]
       end
 
-
       # Returns the factory generator. See WKBParser for details.
-      def factory_generator
-        @factory_generator
-      end
+      attr_reader :factory_generator
 
       # If this parser was given an exact factory, returns it; otherwise
       # returns nil.
-      def exact_factory
-        @exact_factory
-      end
+      attr_reader :exact_factory
 
       # Returns true if this parser supports EWKB.
       # See WKBParser for details.
@@ -97,17 +87,15 @@ module RGeo
         @ignore_extra_bytes
       end
 
-
-      def _properties  # :nodoc:
+      def _properties # :nodoc:
         {
-          'support_ewkb' => @support_ewkb,
-          'support_wkb12' => @support_wkb12,
-          'ignore_extra_bytes' => @ignore_extra_bytes,
-          'default_srid' => @default_srid,
+          "support_ewkb" => @support_ewkb,
+          "support_wkb12" => @support_wkb12,
+          "ignore_extra_bytes" => @ignore_extra_bytes,
+          "default_srid" => @default_srid
         }
       end
 
-
       # Parse the given binary data or hexadecimal string, and return a
       # geometry object.
       #
@@ -115,9 +103,7 @@ module RGeo
       # reasons but deprecated. Use #parse instead.
 
       def parse(data_)
-        if data_[0,1] =~ /[0-9a-fA-F]/
-          data_ = [data_].pack('H*')
-        end
+        data_ = [data_].pack("H*") if data_[0, 1] =~ /[0-9a-fA-F]/
         @cur_has_z = nil
         @cur_has_m = nil
         @cur_srid = nil
@@ -139,8 +125,7 @@ module RGeo
       end
       alias_method :parse_hex, :parse
 
-
-      def _parse_object(contained_)  # :nodoc:
+      def _parse_object(contained_) # :nodoc:
         endian_value_ = _get_byte
         case endian_value_
         when 0
@@ -183,7 +168,7 @@ module RGeo
           @cur_has_m = has_m_
           @cur_dims = 2 + (@cur_has_z ? 1 : 0) + (@cur_has_m ? 1 : 0)
           @cur_srid = srid_
-          @cur_factory = @factory_generator.call(:srid => @cur_srid, :has_z_coordinate => has_z_, :has_m_coordinate => has_m_)
+          @cur_factory = @factory_generator.call(srid: @cur_srid, has_z_coordinate: has_z_, has_m_coordinate: has_m_)
           if @cur_has_z && !@cur_factory.property(:has_z_coordinate)
             raise Error::ParseError, "Data has Z coordinates but the factory doesn't have Z coordinates"
           end
@@ -198,48 +183,43 @@ module RGeo
         when 2
           _parse_line_string(little_endian_)
         when 3
-          interior_rings_ = (1.._get_integer(little_endian_)).map{ _parse_line_string(little_endian_) }
+          interior_rings_ = (1.._get_integer(little_endian_)).map { _parse_line_string(little_endian_) }
           exterior_ring_ = interior_rings_.shift || @cur_factory.linear_ring([])
           @cur_factory.polygon(exterior_ring_, interior_rings_)
         when 4
-          @cur_factory.multi_point((1.._get_integer(little_endian_)).map{ _parse_object(1) })
+          @cur_factory.multi_point((1.._get_integer(little_endian_)).map { _parse_object(1) })
         when 5
-          @cur_factory.multi_line_string((1.._get_integer(little_endian_)).map{ _parse_object(2) })
+          @cur_factory.multi_line_string((1.._get_integer(little_endian_)).map { _parse_object(2) })
         when 6
-          @cur_factory.multi_polygon((1.._get_integer(little_endian_)).map{ _parse_object(3) })
+          @cur_factory.multi_polygon((1.._get_integer(little_endian_)).map { _parse_object(3) })
         when 7
-          @cur_factory.collection((1.._get_integer(little_endian_)).map{ _parse_object(true) })
+          @cur_factory.collection((1.._get_integer(little_endian_)).map { _parse_object(true) })
         else
           raise Error::ParseError, "Unknown type value: #{type_code_}."
         end
       end
 
-
-      def _parse_line_string(little_endian_)  # :nodoc:
+      def _parse_line_string(little_endian_) # :nodoc:
         count_ = _get_integer(little_endian_)
         coords_ = _get_doubles(little_endian_, @cur_dims * count_)
-        @cur_factory.line_string((0...count_).map{ |i_| @cur_factory.point(*coords_[@cur_dims*i_,@cur_dims]) })
+        @cur_factory.line_string((0...count_).map { |i_| @cur_factory.point(*coords_[@cur_dims * i_, @cur_dims]) })
       end
 
-
-      def _start_scanner(data_)  # :nodoc:
+      def _start_scanner(data_) # :nodoc:
         @_data = data_
         @_len = data_.length
         @_pos = 0
       end
 
-
-      def _clean_scanner  # :nodoc:
+      def _clean_scanner # :nodoc:
         @_data = nil
       end
 
-
-      def _bytes_remaining  # :nodoc:
+      def _bytes_remaining # :nodoc:
         @_len - @_pos
       end
 
-
-      def _get_byte  # :nodoc:
+      def _get_byte # :nodoc:
         if @_pos + 1 > @_len
           raise Error::ParseError, "Not enough bytes left to fulfill 1 byte"
         end
@@ -248,8 +228,7 @@ module RGeo
         str_.unpack("C").first
       end
 
-
-      def _get_integer(little_endian_)  # :nodoc:
+      def _get_integer(little_endian_) # :nodoc:
         if @_pos + 4 > @_len
           raise Error::ParseError, "Not enough bytes left to fulfill 1 integer"
         end
@@ -258,8 +237,7 @@ module RGeo
         str_.unpack("#{little_endian_ ? 'V' : 'N'}").first
       end
 
-
-      def _get_doubles(little_endian_, count_)  # :nodoc:
+      def _get_doubles(little_endian_, count_) # :nodoc:
         len_ = 8 * count_
         if @_pos + len_ > @_len
           raise Error::ParseError, "Not enough bytes left to fulfill #{count_} doubles"
@@ -268,11 +246,6 @@ module RGeo
         @_pos += len_
         str_.unpack("#{little_endian_ ? 'E' : 'G'}*")
       end
-
-
     end
-
-
   end
-
 end

data/lib/rgeo/wkrep/wkt_generator.rb

@@ -5,10 +5,7 @@
 # -----------------------------------------------------------------------------
 
 module RGeo
-
   module WKRep
-
-
     # This class provides the functionality of serializing a geometry as
     # WKT (well-known text) format. You may also customize the serializer
     # to generate PostGIS EWKT extensions to the output, or to follow the
@@ -48,12 +45,10 @@ module RGeo
     #   generator to emphasize readability.) Default is nil.
 
     class WKTGenerator
-
-
       # Create and configure a WKT generator. See the WKTGenerator
       # documentation for the options that can be passed.
 
-      def initialize(opts_={})
+      def initialize(opts_ = {})
         @tag_format = opts_[:tag_format] || opts_[:type_format] || :wkt11
         @emit_ewkt_srid = @tag_format == :ewkt ?
           (opts_[:emit_ewkt_srid] ? true : false) : nil
@@ -61,11 +56,8 @@ module RGeo
         @convert_case = opts_[:convert_case]
       end
 
-
       # Returns the format for type tags. See WKTGenerator for details.
-      def tag_format
-        @tag_format
-      end
+      attr_reader :tag_format
       alias_method :type_format, :tag_format
 
       # Returns whether SRID is embedded. See WKTGenerator for details.
@@ -80,27 +72,23 @@ module RGeo
       end
 
       # Returns the case for output. See WKTGenerator for details.
-      def convert_case
-        @convert_case
-      end
-
+      attr_reader :convert_case
 
-      def _properties  # :nodoc:
+      def _properties # :nodoc:
         {
-          'tag_format' => @tag_format.to_s,
-          'emit_ewkt_srid' => @emit_ewkt_srid,
-          'square_brackets' => @square_brackets,
-          'convert_case' => @convert_case ? @convert_case.to_s : nil,
+          "tag_format" => @tag_format.to_s,
+          "emit_ewkt_srid" => @emit_ewkt_srid,
+          "square_brackets" => @square_brackets,
+          "convert_case" => @convert_case ? @convert_case.to_s : nil
         }
       end
 
-
       # Generate and return the WKT format for the given geometry object,
       # according to the current settings.
 
       def generate(obj_)
-        @begin_bracket = @square_brackets ? '[' : '('
-        @end_bracket = @square_brackets ? ']' : ')'
+        @begin_bracket = @square_brackets ? "[" : "("
+        @end_bracket = @square_brackets ? "]" : ")"
         factory_ = obj_.factory
         if @tag_format == :wkt11_strict
           @cur_support_z = nil
@@ -119,27 +107,22 @@ module RGeo
         end
       end
 
-
-      def _generate_feature(obj_, toplevel_=false)  # :nodoc:
+      def _generate_feature(obj_, toplevel_ = false) # :nodoc:
         type_ = obj_.geometry_type
         type_ = Feature::LineString if type_.subtype_of?(Feature::LineString)
         tag_ = type_.type_name
         if @tag_format == :ewkt
-          if @cur_support_m && !@cur_support_z
-            tag_ << 'M'
-          end
-          if toplevel_ && @emit_ewkt_srid
-            tag_ = "SRID=#{obj_.srid};#{tag_}"
-          end
+          tag_ << "M" if @cur_support_m && !@cur_support_z
+          tag_ = "SRID=#{obj_.srid};#{tag_}" if toplevel_ && @emit_ewkt_srid
         elsif @tag_format == :wkt12
           if @cur_support_z
             if @cur_support_m
-              tag_ << ' ZM'
+              tag_ << " ZM"
             else
-              tag_ << ' Z'
+              tag_ << " Z"
             end
           elsif @cur_support_m
-            tag_ << ' M'
+            tag_ << " M"
           end
         end
         if type_ == Feature::Point
@@ -161,77 +144,64 @@ module RGeo
         end
       end
 
-
-      def _generate_coords(obj_)  # :nodoc:
-        str_ = "#{obj_.x.to_s} #{obj_.y.to_s}"
-        str_ << " #{obj_.z.to_s}" if @cur_support_z
-        str_ << " #{obj_.m.to_s}" if @cur_support_m
+      def _generate_coords(obj_) # :nodoc:
+        str_ = "#{obj_.x} #{obj_.y}"
+        str_ << " #{obj_.z}" if @cur_support_z
+        str_ << " #{obj_.m}" if @cur_support_m
         str_
       end
 
-
-      def _generate_point(obj_)  # :nodoc:
+      def _generate_point(obj_) # :nodoc:
         "#{@begin_bracket}#{_generate_coords(obj_)}#{@end_bracket}"
       end
 
-
-      def _generate_line_string(obj_)  # :nodoc:
+      def _generate_line_string(obj_) # :nodoc:
         if obj_.is_empty?
-          'EMPTY'
+          "EMPTY"
         else
-          "#{@begin_bracket}#{obj_.points.map{ |p_| _generate_coords(p_) }.join(', ')}#{@end_bracket}"
+          "#{@begin_bracket}#{obj_.points.map { |p_| _generate_coords(p_) }.join(', ')}#{@end_bracket}"
         end
       end
 
-
-      def _generate_polygon(obj_)  # :nodoc:
+      def _generate_polygon(obj_) # :nodoc:
         if obj_.is_empty?
-          'EMPTY'
+          "EMPTY"
         else
-          "#{@begin_bracket}#{([_generate_line_string(obj_.exterior_ring)] + obj_.interior_rings.map{ |r_| _generate_line_string(r_) }).join(', ')}#{@end_bracket}"
+          "#{@begin_bracket}#{([_generate_line_string(obj_.exterior_ring)] + obj_.interior_rings.map { |r_| _generate_line_string(r_) }).join(', ')}#{@end_bracket}"
         end
       end
 
-
-      def _generate_geometry_collection(obj_)  # :nodoc:
+      def _generate_geometry_collection(obj_) # :nodoc:
         if obj_.is_empty?
-          'EMPTY'
+          "EMPTY"
         else
-          "#{@begin_bracket}#{obj_.map{ |f_| _generate_feature(f_) }.join(', ')}#{@end_bracket}"
+          "#{@begin_bracket}#{obj_.map { |f_| _generate_feature(f_) }.join(', ')}#{@end_bracket}"
         end
       end
 
-
-      def _generate_multi_point(obj_)  # :nodoc:
+      def _generate_multi_point(obj_) # :nodoc:
         if obj_.is_empty?
-          'EMPTY'
+          "EMPTY"
         else
-          "#{@begin_bracket}#{obj_.map{ |f_| _generate_point(f_) }.join(', ')}#{@end_bracket}"
+          "#{@begin_bracket}#{obj_.map { |f_| _generate_point(f_) }.join(', ')}#{@end_bracket}"
         end
       end
 
-
-      def _generate_multi_line_string(obj_)  # :nodoc:
+      def _generate_multi_line_string(obj_) # :nodoc:
         if obj_.is_empty?
-          'EMPTY'
+          "EMPTY"
         else
-          "#{@begin_bracket}#{obj_.map{ |f_| _generate_line_string(f_) }.join(', ')}#{@end_bracket}"
+          "#{@begin_bracket}#{obj_.map { |f_| _generate_line_string(f_) }.join(', ')}#{@end_bracket}"
         end
       end
 
-
-      def _generate_multi_polygon(obj_)  # :nodoc:
+      def _generate_multi_polygon(obj_) # :nodoc:
         if obj_.is_empty?
-          'EMPTY'
+          "EMPTY"
         else
-          "#{@begin_bracket}#{obj_.map{ |f_| _generate_polygon(f_) }.join(', ')}#{@end_bracket}"
+          "#{@begin_bracket}#{obj_.map { |f_| _generate_polygon(f_) }.join(', ')}#{@end_bracket}"
         end
       end
-
-
     end
-
-
   end
-
 end

data/lib/rgeo/wkrep/wkt_parser.rb

@@ -4,14 +4,10 @@
 #
 # -----------------------------------------------------------------------------
 
-require 'strscan'
-
+require "strscan"
 
 module RGeo
-
   module WKRep
-
-
     # This class provides the functionality of parsing a geometry from
     # WKT (well-known text) format. You may also customize the parser
     # to recognize PostGIS EWKT extensions to the input, or Simple
@@ -52,13 +48,11 @@ module RGeo
     #   the input. Defaults to nil (i.e. don't specify a SRID).
 
     class WKTParser
-
-
       # Create and configure a WKT parser. See the WKTParser
       # documentation for the options that can be passed.
 
-      def initialize(factory_generator_=nil, opts_={})
-        if factory_generator_.kind_of?(Feature::Factory::Instance)
+      def initialize(factory_generator_ = nil, opts_ = {})
+        if factory_generator_.is_a?(Feature::Factory::Instance)
           @factory_generator = Feature::FactoryGenerator.single(factory_generator_)
           @exact_factory = factory_generator_
         elsif factory_generator_.respond_to?(:call)
@@ -75,17 +69,12 @@ module RGeo
         @default_srid = opts_[:default_srid]
       end
 
-
       # Returns the factory generator. See WKTParser for details.
-      def factory_generator
-        @factory_generator
-      end
+      attr_reader :factory_generator
 
       # If this parser was given an exact factory, returns it; otherwise
       # returns nil.
-      def exact_factory
-        @exact_factory
-      end
+      attr_reader :exact_factory
 
       # Returns true if this parser supports EWKT.
       # See WKTParser for details.
@@ -111,18 +100,16 @@ module RGeo
         @ignore_extra_tokens
       end
 
-
-      def _properties  # :nodoc:
+      def _properties # :nodoc:
         {
-          'support_ewkt' => @support_ewkt,
-          'support_wkt12' => @support_wkt12,
-          'strict_wkt11' => @strict_wkt11,
-          'ignore_extra_tokens' => @ignore_extra_tokens,
-          'default_srid' => @default_srid,
+          "support_ewkt" => @support_ewkt,
+          "support_wkt12" => @support_wkt12,
+          "strict_wkt11" => @strict_wkt11,
+          "ignore_extra_tokens" => @ignore_extra_tokens,
+          "default_srid" => @default_srid
         }
       end
 
-
       # Parse the given string, and return a geometry object.
 
       def parse(str_)
@@ -137,7 +124,7 @@ module RGeo
         @cur_srid = @default_srid
         if @support_ewkt && str_ =~ /^srid=(\d+);/i
           str_ = $'
-          @cur_srid = $1.to_i
+          @cur_srid = Regexp.last_match(1).to_i
         end
         begin
           _start_scanner(str_)
@@ -151,8 +138,7 @@ module RGeo
         obj_
       end
 
-
-      def _check_factory_support  # :nodoc:
+      def _check_factory_support # :nodoc:
         if @cur_expect_z && !@cur_factory_support_z
           raise Error::ParseError, "Geometry calls for Z coordinate but factory doesn't support it."
         end
@@ -161,10 +147,9 @@ module RGeo
         end
       end
 
-
-      def _ensure_factory  # :nodoc:
+      def _ensure_factory # :nodoc:
         unless @cur_factory
-          @cur_factory = @factory_generator.call(:srid => @cur_srid, :has_z_coordinate => @cur_expect_z, :has_m_coordinate => @cur_expect_m)
+          @cur_factory = @factory_generator.call(srid: @cur_srid, has_z_coordinate: @cur_expect_z, has_m_coordinate: @cur_expect_m)
           @cur_factory_support_z = @cur_factory.property(:has_z_coordinate) ? true : false
           @cur_factory_support_m = @cur_factory.property(:has_m_coordinate) ? true : false
           _check_factory_support unless @cur_expect_z.nil?
@@ -172,30 +157,29 @@ module RGeo
         @cur_factory
       end
 
-
-      def _parse_type_tag(contained_)  # :nodoc:
+      def _parse_type_tag(_contained_) # :nodoc:
         _expect_token_type(::String)
         if @support_ewkt && @cur_token =~ /^(.+)(m)$/
-          type_ = $1
-          zm_ = $2
+          type_ = Regexp.last_match(1)
+          zm_ = Regexp.last_match(2)
         else
           type_ = @cur_token
-          zm_ = ''
+          zm_ = ""
         end
         _next_token
-        if zm_.length == 0 && @support_wkt12 && @cur_token.kind_of?(::String) && @cur_token =~ /^z?m?$/
+        if zm_.length == 0 && @support_wkt12 && @cur_token.is_a?(::String) && @cur_token =~ /^z?m?$/
           zm_ = @cur_token
           _next_token
         end
         if zm_.length > 0 || @strict_wkt11
           creating_expectation_ = @cur_expect_z.nil?
-          expect_z_ = zm_[0,1] == 'z' ? true : false
+          expect_z_ = zm_[0, 1] == "z" ? true : false
           if @cur_expect_z.nil?
             @cur_expect_z = expect_z_
           elsif expect_z_ != @cur_expect_z
             raise Error::ParseError, "Surrounding collection has Z but contained geometry doesn't."
           end
-          expect_m_ = zm_[-1,1] == 'm' ? true : false
+          expect_m_ = zm_[-1, 1] == "m" ? true : false
           if @cur_expect_m.nil?
             @cur_expect_m = expect_m_
           elsif expect_m_ != @cur_expect_m
@@ -210,27 +194,26 @@ module RGeo
           end
         end
         case type_
-        when 'point'
+        when "point"
           _parse_point(true)
-        when 'linestring'
+        when "linestring"
           _parse_line_string
-        when 'polygon'
+        when "polygon"
           _parse_polygon
-        when 'geometrycollection'
+        when "geometrycollection"
           _parse_geometry_collection
-        when 'multipoint'
+        when "multipoint"
           _parse_multi_point
-        when 'multilinestring'
+        when "multilinestring"
           _parse_multi_line_string
-        when 'multipolygon'
+        when "multipolygon"
           _parse_multi_polygon
         else
           raise Error::ParseError, "Unknown type tag: #{type_.inspect}."
         end
       end
 
-
-      def _parse_coords  # :nodoc:
+      def _parse_coords # :nodoc:
         _expect_token_type(::Numeric)
         x_ = @cur_token
         _next_token
@@ -249,7 +232,7 @@ module RGeo
           @cur_expect_m = num_extras_ > 0 && (!@cur_factory || @cur_factory_support_m) ? true : false
           num_extras_ -= 1 if @cur_expect_m
           if num_extras_ > 0
-            raise Error::ParseError, "Found #{extra_.size+2} coordinates, which is too many for this factory."
+            raise Error::ParseError, "Found #{extra_.size + 2} coordinates, which is too many for this factory."
           end
           _ensure_factory
         else
@@ -259,25 +242,20 @@ module RGeo
             val_ = @cur_token
             _next_token
           end
-          if @cur_factory_support_z
-            extra_ << val_
-          end
+          extra_ << val_ if @cur_factory_support_z
           val_ = 0
           if @cur_expect_m
             _expect_token_type(::Numeric)
             val_ = @cur_token
             _next_token
           end
-          if @cur_factory_support_m
-            extra_ << val_
-          end
+          extra_ << val_ if @cur_factory_support_m
         end
         @cur_factory.point(x_, y_, *extra_)
       end
 
-
-      def _parse_point(convert_empty_=false)  # :nodoc:
-        if convert_empty_ && @cur_token == 'empty'
+      def _parse_point(convert_empty_ = false) # :nodoc:
+        if convert_empty_ && @cur_token == "empty"
           point_ = _ensure_factory.multi_point([])
         else
           _expect_token_type(:begin)
@@ -289,10 +267,9 @@ module RGeo
         point_
       end
 
-
-      def _parse_line_string  # :nodoc:
+      def _parse_line_string # :nodoc:
         points_ = []
-        if @cur_token != 'empty'
+        if @cur_token != "empty"
           _expect_token_type(:begin)
           _next_token
           loop do
@@ -306,10 +283,9 @@ module RGeo
         _ensure_factory.line_string(points_)
       end
 
-
-      def _parse_polygon  # :nodoc:
+      def _parse_polygon # :nodoc:
         inner_rings_ = []
-        if @cur_token == 'empty'
+        if @cur_token == "empty"
           outer_ring_ = _ensure_factory.linear_ring([])
         else
           _expect_token_type(:begin)
@@ -326,10 +302,9 @@ module RGeo
         _ensure_factory.polygon(outer_ring_, inner_rings_)
       end
 
-
-      def _parse_geometry_collection  # :nodoc:
+      def _parse_geometry_collection # :nodoc:
         geometries_ = []
-        if @cur_token != 'empty'
+        if @cur_token != "empty"
           _expect_token_type(:begin)
           _next_token
           loop do
@@ -343,10 +318,9 @@ module RGeo
         _ensure_factory.collection(geometries_)
       end
 
-
-      def _parse_multi_point  # :nodoc:
+      def _parse_multi_point # :nodoc:
         points_ = []
-        if @cur_token != 'empty'
+        if @cur_token != "empty"
           _expect_token_type(:begin)
           _next_token
           loop do
@@ -366,10 +340,9 @@ module RGeo
         _ensure_factory.multi_point(points_)
       end
 
-
-      def _parse_multi_line_string  # :nodoc:
+      def _parse_multi_line_string # :nodoc:
         line_strings_ = []
-        if @cur_token != 'empty'
+        if @cur_token != "empty"
           _expect_token_type(:begin)
           _next_token
           loop do
@@ -383,10 +356,9 @@ module RGeo
         _ensure_factory.multi_line_string(line_strings_)
       end
 
-
       def _parse_multi_polygon  # :nodoc:
         polygons_ = []
-        if @cur_token != 'empty'
+        if @cur_token != "empty"
           _expect_token_type(:begin)
           _next_token
           loop do
@@ -400,27 +372,23 @@ module RGeo
         _ensure_factory.multi_polygon(polygons_)
       end
 
-
       def _start_scanner(str_)  # :nodoc:
         @_scanner = ::StringScanner.new(str_)
         _next_token
       end
 
-
-      def _clean_scanner  # :nodoc:
+      def _clean_scanner # :nodoc:
         @_scanner = nil
         @cur_token = nil
       end
 
-
-      def _expect_token_type(type_)  # :nodoc:
+      def _expect_token_type(type_) # :nodoc:
         unless type_ === @cur_token
           raise Error::ParseError, "#{type_.inspect} expected but #{@cur_token.inspect} found."
         end
       end
 
-
-      def _next_token  # :nodoc:
+      def _next_token # :nodoc:
         if @_scanner.scan_until(/\(|\)|\[|\]|,|[^\s\(\)\[\],]+/)
           token_ = @_scanner.matched
           case token_
@@ -428,11 +396,11 @@ module RGeo
             @cur_token = token_.to_f
           when /^[a-z]+$/
             @cur_token = token_
-          when ','
+          when ","
             @cur_token = :comma
-          when '(','['
+          when "(", "["
             @cur_token = :begin
-          when ']',')'
+          when "]", ")"
             @cur_token = :end
           else
             raise Error::ParseError, "Bad token: #{token_.inspect}"
@@ -442,11 +410,6 @@ module RGeo
         end
         @cur_token
       end
-
-
     end
-
-
   end
-
 end