rgeo 0.1.14 → 0.1.15

data/lib/rgeo/wkrep/wkb_parser.rb

@@ -39,24 +39,132 @@ 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
+    # Features Specification 1.2 extensions for Z and M coordinates.
+    # 
+    # To use this class, create an instance with the desired settings and
+    # customizations, and call the parse method.
+    # 
+    # === Configuration options
+    # 
+    # The following options are recognized. These can be passed to the
+    # constructor, or set on the object afterwards.
+    # 
+    # <tt>:default_factory</tt>::
+    #   The default factory for generated geometries, used when no SRID
+    #   is explicitly specified in the input. If none is provided, the
+    #   default cartesian factory will be used.
+    # <tt>:factory_from_srid</tt>::
+    #   A Proc that takes an SRID as the sole argument, and returns a
+    #   factory for generated geometries when that SRID is specified in
+    #   the input. If no such Proc is provided, the default_factory is
+    #   used, regardless of the input SRID.
+    # <tt>:support_ewkb</tt>::
+    #   Activate support for PostGIS EWKB type codes, which use high
+    #   order bits in the type code to signal the presence of Z, M, and
+    #   SRID values in the data. Default is false.
+    # <tt>:support_wkb12</tt>::
+    #   Activate support for SFS 1.2 extensions to the type codes, which
+    #   use values greater than 1000 to signal the presence of Z and M
+    #   values in the data. SFS 1.2 types such as triangle, tin, and
+    #   polyhedralsurface are NOT yet supported. Default is false.
+    # <tt>:ignore_extra_bytes</tt>::
+    #   If true, extra bytes at the end of the data are ignored. If
+    #   false (the default), extra bytes will trigger a parse error.
+    
     class WKBParser
       
       
-      def initialize(factory_, opts_={}, &block_)
-        @factory = factory_
-        @factory_factory = block_
-        @support_ewkb = opts_[:support_ewkb]
-        @support_wkb12 = opts_[:support_wkb12]
-        @ignore_extra_bytes = opts_[:ignore_extra_bytes]
+      # Create and configure a WKB parser. See the WKBParser
+      # documentation for the options that can be passed.
+      
+      def initialize(opts_={})
+        @default_factory = opts_[:default_factory] || Cartesian.preferred_factory
+        @factory_from_srid = opts_[:factory_from_srid]
+        @support_ewkb = opts_[:support_ewkb] ? true : false
+        @support_wkb12 = opts_[:support_wkb12] ? true : false
+        @ignore_extra_bytes = opts_[:ignore_extra_bytes] ? true : false
+      end
+      
+      
+      # Returns the default factory. See WKBParser for details.
+      def default_factory
+        @default_factory
+      end
+      
+      # Sets the default factory. See WKBParser for details.
+      def default_factory=(value_)
+        @default_factory = value_ || Cartesian.preferred_factory
+      end
+      
+      # Returns true if this parser has a factory_from_srid procedure.
+      # See WKBParser for details.
+      def has_factory_from_srid?
+        @factory_from_srid ? true : false
+      end
+      
+      # Sets the factory_from_srid. See WKBParser for details.
+      def factory_from_srid=(value_)
+        @factory_from_srid = value_
+      end
+      
+      # Sets the factory_from_srid to the given block.
+      # See WKBParser for details.
+      def set_factory_from_srid(&block_)
+        @factory_from_srid = block_
+      end
+      
+      # Returns true if this parser supports EWKB.
+      # See WKBParser for details.
+      def support_ewkb?
+        @support_ewkb
+      end
+      
+      # Sets the the support_ewkb flag. See WKBParser for details.
+      def support_ewkb=(value_)
+        @support_ewkb = value_ ? true : false
+      end
+      
+      # Returns true if this parser supports SFS 1.2 extensions.
+      # See WKBParser for details.
+      def support_wkb12?
+        @support_wkb12
+      end
+      
+      # Sets the the support_wkb12 flag. See WKBParser for details.
+      def support_wkb12=(value_)
+        @support_wkb12 = value_ ? true : false
+      end
+      
+      # Returns true if this parser ignores extra bytes.
+      # See WKBParser for details.
+      def ignore_extra_bytes?
+        @ignore_extra_bytes
       end
       
+      # Sets the the ignore_extra_bytes flag. See WKBParser for details.
+      def ignore_extra_bytes=(value_)
+        @ignore_extra_bytes = value_ ? true : false
+      end
+      
+      
+      # Parse the given hex string, and return a geometry object.
+      
+      def parse_hex(str_)
+        parse([str_].pack('H*'))
+      end
+      
+      
+      # Parse the given binary data, and return a geometry object.
       
       def parse(data_)
         @cur_has_z = nil
         @cur_has_m = nil
         @cur_srid = nil
         @cur_dims = 2
-        @cur_factory = @factory
+        @cur_factory = @default_factory
         begin
           _start_scanner(data_)
           obj_ = _parse_object(false)
@@ -108,8 +216,8 @@ module RGeo
           @cur_has_m = has_m_
           @cur_dims = 2 + (@cur_has_z ? 1 : 0) + (@cur_has_m ? 1 : 0)
           @cur_srid = srid_
-          if srid_ && @factory_factory
-            @cur_factory = @factory_factory.call(srid_)
+          if srid_ && @factory_from_srid
+            @cur_factory = @factory_from_srid.call(srid_)
           end
           if @cur_has_z && !@cur_factory.has_capability?(:z_coordinate)
             raise Errors::ParseError, "Data has Z coordinates but the factory doesn't have z_coordinate capability"

data/lib/rgeo/wkrep/wkt_generator.rb

@@ -39,19 +39,107 @@ 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
+    # Simple Features Specification 1.2 extensions for Z and M.
+    # 
+    # To use this class, create an instance with the desired settings and
+    # customizations, and call the generate method.
+    # 
+    # === Configuration options
+    # 
+    # The following options are recognized. These can be passed to the
+    # constructor, or set on the object afterwards.
+    # 
+    # <tt>:tag_format</tt>::
+    #   The format for tags. Possible values are <tt>:wkt11</tt>,
+    #   indicating SFS 1.1 WKT (i.e. no Z or M markers in the tags) but
+    #   with Z and/or M values added in if they are present;
+    #   <tt>:wkt11_strict</tt>, indicating SFS 1.1 WKT with Z and M
+    #   dropped from the output (since WKT strictly does not support
+    #   the Z or M dimensions); <tt>:ewkt</tt>, indicating the PostGIS
+    #   EWKT extensions (i.e. "M" appended to tag names if M but not
+    #   Z is present); or <tt>:wkt12</tt>, indicating SFS 1.2 WKT
+    #   tags that indicate the presence of Z and M in a separate token.
+    #   Default is <tt>:wkt11</tt>.
+    # <tt>:emit_ewkt_srid</tt>::
+    #   If true, embed the SRID of the toplevel geometry. Available only
+    #   if <tt>:type_format</tt> is <tt>:ewkt</tt>. Default is false.
+    # <tt>:square_brackets</tt>::
+    #   If true, uses square brackets rather than parentheses.
+    #   Default is false.
+    # <tt>:convert_case</tt>::
+    #   Possible values are <tt>:upper</tt>, which changes all letters
+    #   in the output to ALL CAPS; <tt>:lower</tt>, which changes all
+    #   letters to lower case; or nil, indicating no case changes from
+    #   the default (which is not specified exactly, but is chosen by the
+    #   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_={})
-        @tag_format = opts_[:tag_format]
-        @emit_ewkt_srid = opts_[:emit_ewkt_srid] if @tag_format == :ewkt
-        @begin_bracket = opts_[:square_brackets] ? '[' : '('
-        @end_bracket = opts_[:square_brackets] ? ']' : ')'
-        @case = opts_[:case]
+        @tag_format = opts_[:tag_format] || :wkt11
+        @emit_ewkt_srid = opts_[:emit_ewkt_srid] ? true : false if @tag_format == :ewkt
+        @square_brackets = opts_[:square_brackets] ? true : false
+        @convert_case = opts_[:convert_case]
       end
       
       
+      # Returns the format for type tags. See WKTGenerator for details.
+      def tag_format
+        @tag_format
+      end
+      
+      # Sets the format for type tags. See WKTGenerator for details.
+      def tag_format=(value_)
+        @tag_format = value_
+      end
+      
+      # Returns whether SRID is embedded. See WKTGenerator for details.
+      def emit_ewkt_srid?
+        @emit_ewkt_srid
+      end
+      
+      # Sets whether SRID is embedded. Available only when the tag_format
+      # is <tt>:ewkt</tt>. See WKTGenerator for details.
+      def emit_ewkt_srid=(value_)
+        @emit_ewkt_srid = @type_format == :ewkt && value_
+      end
+      
+      # Returns whether square brackets rather than parens are output.
+      # See WKTGenerator for details.
+      def square_brackets?
+        @square_brackets
+      end
+      
+      # Sets whether square brackets rather than parens are output.
+      # See WKTGenerator for details.
+      def square_brackets=(value_)
+        @square_brackets = value_ ? true : false
+      end
+      
+      # Returns the case for output. See WKTGenerator for details.
+      def convert_case
+        @convert_case
+      end
+      
+      # Sets the case for output. See WKTGenerator for details.
+      def convert_case=(value_)
+        @convert_case = value_
+      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 ? ']' : ')'
         factory_ = obj_.factory
         if @tag_format == :wkt11_strict
           @cur_support_z = nil
@@ -61,9 +149,9 @@ module RGeo
           @cur_support_m = factory_.has_capability?(:m_coordinate)
         end
         str_ = _generate_feature(obj_, true)
-        if @case == :upper
+        if @convert_case == :upper
           str_.upcase
-        elsif @case == :lower
+        elsif @convert_case == :lower
           str_.downcase
         else
           str_
@@ -78,6 +166,9 @@ module RGeo
           if @cur_support_m && !@cur_support_z
             tag_ << 'M'
           end
+          if toplevel_ && @emit_ewkt_srid
+            tag_ = "SRID=#{obj_.srid};#{tag_}"
+          end
         elsif @tag_format == :wkt12
           if @cur_support_z
             if @cur_support_m
@@ -89,9 +180,6 @@ module RGeo
             tag_ << ' M'
           end
         end
-        if toplevel_ && @emit_ewkt_srid
-          tag_ = "SRID=#{obj_.srid};#{tag_}"
-        end
         if type_ == Features::Point
           tag_ + _generate_point(obj_)
         elsif type_.subtype_of?(Features::LineString)
@@ -125,27 +213,27 @@ module RGeo
       end
       
       
-      def _generate_line_string(obj_)  # :nodoc:
+      def _generate_line_string(obj_, contained_=false)  # :nodoc:
         if obj_.is_empty?
-          " EMPTY"
+          contained_ ? 'EMPTY' : ' EMPTY'
         else
           "#{@begin_bracket}#{obj_.points.map{ |p_| _generate_coords(p_) }.join(',')}#{@end_bracket}"
         end
       end
       
       
-      def _generate_polygon(obj_)  # :nodoc:
+      def _generate_polygon(obj_, contained_=false)  # :nodoc:
         if obj_.is_empty?
-          " EMPTY"
+          contained_ ? '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, true)] + obj_.interior_rings.map{ |r_| _generate_line_string(r_, true) }).join(',')}#{@end_bracket}"
         end
       end
       
       
       def _generate_geometry_collection(obj_)  # :nodoc:
         if obj_.is_empty?
-          " EMPTY"
+          ' EMPTY'
         else
           "#{@begin_bracket}#{obj_.map{ |f_| _generate_feature(f_) }.join(',')}#{@end_bracket}"
         end
@@ -165,7 +253,7 @@ module RGeo
         if obj_.is_empty?
           " EMPTY"
         else
-          "#{@begin_bracket}#{obj_.map{ |f_| _generate_line_string(f_) }.join(',')}#{@end_bracket}"
+          "#{@begin_bracket}#{obj_.map{ |f_| _generate_line_string(f_, true) }.join(',')}#{@end_bracket}"
         end
       end
       
@@ -174,7 +262,7 @@ module RGeo
         if obj_.is_empty?
           " EMPTY"
         else
-          "#{@begin_bracket}#{obj_.map{ |f_| _generate_polygon(f_) }.join(',')}#{@end_bracket}"
+          "#{@begin_bracket}#{obj_.map{ |f_| _generate_polygon(f_, true) }.join(',')}#{@end_bracket}"
         end
       end
       

data/lib/rgeo/wkrep/wkt_parser.rb

@@ -42,42 +42,164 @@ 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
+    # Features Specification 1.2 extensions for Z and M coordinates.
+    # 
+    # To use this class, create an instance with the desired settings and
+    # customizations, and call the parse method.
+    # 
+    # === Configuration options
+    # 
+    # The following options are recognized. These can be passed to the
+    # constructor, or set on the object afterwards.
+    # 
+    # <tt>:default_factory</tt>::
+    #   The default factory for generated geometries, used when no SRID
+    #   is explicitly specified in the input. If none is provided, the
+    #   default cartesian factory will be used.
+    # <tt>:factory_from_srid</tt>::
+    #   A Proc that takes an SRID as the sole argument, and returns a
+    #   factory for generated geometries when that SRID is specified in
+    #   the input. If no such Proc is provided, the default_factory is
+    #   used, regardless of the input SRID.
+    # <tt>:support_ewkt</tt>::
+    #   Activate support for PostGIS EWKT type tags, which appends an "M"
+    #   to tags to indicate the presence of M but not Z, and also
+    #   recognizes the SRID prefix. Default is false.
+    # <tt>:support_wkt12</tt>::
+    #   Activate support for SFS 1.2 extensions to the type codes, which
+    #   use a "M", "Z", or "ZM" token to signal the presence of Z and M
+    #   values in the data. SFS 1.2 types such as triangle, tin, and
+    #   polyhedralsurface are NOT yet supported. Default is false.
+    # <tt>:strict_wkt11</tt>::
+    #   If true, parsing will proceed in SFS 1.1 strict mode, which
+    #   disallows any values other than X or Y. This has no effect if
+    #   support_ewkt or support_wkt12 are active. Default is false.
+    # <tt>:ignore_extra_tokens</tt>::
+    #   If true, extra tokens at the end of the data are ignored. If
+    #   false (the default), extra tokens will trigger a parse error.
+    
     class WKTParser
       
       
-      def initialize(factory_, opts_={}, &block_)
-        @factory = factory_
-        @factory_factory = block_
-        @support_ewkt = opts_[:support_ewkt]
-        @support_wkt12 = opts_[:support_wkt12]
-        @support_higher_dimensions = opts_[:support_higher_dimensions] || @support_ewkt || @support_wkt12
-        @ignore_extra_tokens = opts_[:ignore_extra_tokens]
+      # Create and configure a WKT parser. See the WKTParser
+      # documentation for the options that can be passed.
+      
+      def initialize(opts_={})
+        @default_factory = opts_[:default_factory] || Cartesian.preferred_factory
+        @factory_from_srid = opts_[:factory_from_srid]
+        @support_ewkt = opts_[:support_ewkt] ? true : false
+        @support_wkt12 = opts_[:support_wkt12] ? true : false
+        @strict_wkt11 = @support_ewkt || @support_wkt12 ? false : opts_[:strict_wkt11] ? true : false
+        @ignore_extra_tokens = opts_[:ignore_extra_tokens] ? true : false
+      end
+      
+      
+      # Returns the default factory. See WKTParser for details.
+      def default_factory
+        @default_factory
+      end
+      
+      # Sets the default factory. See WKTParser for details.
+      def default_factory=(value_)
+        @default_factory = value_ || Cartesian.preferred_factory
+      end
+      
+      # Returns true if this parser has a factory_from_srid procedure.
+      # See WKTParser for details.
+      def has_factory_from_srid?
+        @factory_from_srid ? true : false
+      end
+      
+      # Sets the factory_from_srid. See WKTParser for details.
+      def factory_from_srid=(value_)
+        @factory_from_srid = value_
+      end
+      
+      # Sets the factory_from_srid to the given block.
+      # See WKTParser for details.
+      def set_factory_from_srid(&block_)
+        @factory_from_srid = block_
+      end
+      
+      # Returns true if this parser supports EWKT.
+      # See WKTParser for details.
+      def support_ewkt?
+        @support_ewkt
       end
       
+      # Sets the the support_ewkt flag. See WKTParser for details.
+      def support_ewkt=(value_)
+        @support_ewkt = value_ ? true : false
+      end
+      
+      # Returns true if this parser supports SFS 1.2 extensions.
+      # See WKTParser for details.
+      def support_wkt12?
+        @support_wkt12
+      end
+      
+      # Sets the the support_wkt12 flag. See WKTParser for details.
+      def support_wkt12=(value_)
+        @support_wkt12 = value_ ? true : false
+      end
+      
+      # Returns true if this parser strictly adheres to WKT 1.1.
+      # See WKTParser for details.
+      def strict_wkt11?
+        @strict_wkt11
+      end
+      
+      # Sets the the strict_wkt11 flag. See WKTParser for details.
+      def strict_wkt11=(value_)
+        @strict_wkt11 = value_ ? true : false
+      end
+      
+      # Returns true if this parser ignores extra tokens.
+      # See WKTParser for details.
+      def ignore_extra_tokens?
+        @ignore_extra_tokens
+      end
+      
+      # Sets the the ignore_extra_tokens flag. See WKTParser for details.
+      def ignore_extra_tokens=(value_)
+        @ignore_extra_tokens = value_ ? true : false
+      end
+      
+      
+      # Parse the given string, and return a geometry object.
       
       def parse(str_)
-        @cur_factory = @factory
+        @cur_factory = @default_factory
         str_ = str_.downcase
-        if @support_ewkt && str_ =~ /^srid=(\d+);/
+        if @support_ewkt && str_ =~ /^srid=(\d+);/i
           str_ = $'
-          if @factory_factory
-            @cur_factory = @factory_factory.call($1.to_i)
+          if @factory_from_srid
+            @cur_factory = @factory_from_srid.call($1.to_i)
           end
         end
         @cur_factory_support_z = @cur_factory.has_capability?(:z_coordinate)
         @cur_factory_support_m = @cur_factory.has_capability?(:m_coordinate)
-        _start_scanner(str_)
-        obj_ = _parse_type_tag(nil, nil)
-        if @cur_token && !@ignore_extra_tokens
-          raise Errors::ParseError, "Extra tokens beginning with #{@cur_token.inspect}."
+        @cur_expect_z = nil
+        @cur_expect_m = nil
+        begin
+          _start_scanner(str_)
+          obj_ = _parse_type_tag
+          if @cur_token && !@ignore_extra_tokens
+            raise Errors::ParseError, "Extra tokens beginning with #{@cur_token.inspect}."
+          end
+        ensure
+          _clean_scanner
         end
         obj_
       end
       
       
-      def _parse_type_tag(expect_z_, expect_m_)  # :nodoc:
+      def _parse_type_tag  # :nodoc:
         _expect_token_type(::String)
-        if @support_ekwt && @cur_token =~ /^(.+)(z?m?)$/
+        if @support_ewkt && @cur_token =~ /^(.+)(m)$/
           type_ = $1
           zm_ = $2
         else
@@ -89,46 +211,46 @@ module RGeo
           zm_ = @cur_token
           _next_token
         end
-        if zm_.length > 0 || !@support_higher_dimensions
-          nexpect_z_ = zm_[0,1] == 'z'
-          if !expect_z_.nil? && nexpect_z_ != expect_z_
+        if zm_.length > 0 || @strict_wkt11
+          expect_z_ = zm_[0,1] == 'z'
+          if !@cur_expect_z.nil? && expect_z_ != @cur_expect_z
             raise Errors::ParseError, "Surrounding collection has Z but contained geometry doesn't."
           end
-          expect_z_ = nexpect_z_
-          nexpect_m_ = zm_[-1,1] == 'm'
-          if !expect_m_.nil? && nexpect_m_ != expect_m_
+          @cur_expect_z = expect_z_
+          expect_m_ = zm_[-1,1] == 'm'
+          if !@cur_expect_m.nil? && expect_m_ != @cur_expect_m
             raise Errors::ParseError, "Surrounding collection has M but contained geometry doesn't."
           end
-          expect_m_ = nexpect_m_
+          @cur_expect_m = expect_m_
         end
-        if expect_z_ && !@cur_factory_support_z
+        if @cur_expect_z && !@cur_factory_support_z
           raise Errors::ParseError, "Type tag declares #{zm_.inspect} but factory doesn't support Z."
         end
-        if expect_m_ && !@cur_factory_support_m
+        if @cur_expect_m && !@cur_factory_support_m
           raise Errors::ParseError, "Type tag declares #{zm_.inspect} but factory doesn't support M."
         end
         case type_
         when 'point'
-          _parse_point(expect_z_, expect_m_, true)
+          _parse_point(true)
         when 'linestring'
-          _parse_line_string(expect_z_, expect_m_)
+          _parse_line_string
         when 'polygon'
-          _parse_polygon(expect_z_, expect_m_)
+          _parse_polygon
         when 'geometrycollection'
-          _parse_geometry_collection(expect_z_, expect_m_)
+          _parse_geometry_collection
         when 'multipoint'
-          _parse_multi_point(expect_z_, expect_m_)
+          _parse_multi_point
         when 'multilinestring'
-          _parse_multi_line_string(expect_z_, expect_m_)
+          _parse_multi_line_string
         when 'multipolygon'
-          _parse_multi_polygon(expect_z_, expect_m_)
+          _parse_multi_polygon
         else
-          raise Errors::ParseError, "Unknown type tag: #{@cur_token.inspect}."
+          raise Errors::ParseError, "Unknown type tag: #{type_.inspect}."
         end
       end
       
       
-      def _parse_coords(expect_z_, expect_m_)  # :nodoc:
+      def _parse_coords  # :nodoc:
         _expect_token_type(::Numeric)
         x_ = @cur_token
         _next_token
@@ -136,34 +258,50 @@ module RGeo
         y_ = @cur_token
         _next_token
         extra_ = []
-        if expect_z_.nil?
+        if @cur_expect_z.nil?
           while ::Numeric === @cur_token
             extra_ << @cur_token
             _next_token
           end
+          num_extras_ = extra_.size
+          @cur_expect_z = num_extras_ > 0 && @cur_factory_support_z ? true : false
+          num_extras_ -= 1 if @cur_expect_z
+          @cur_expect_m = num_extras_ > 0 && @cur_factory_support_m ? true : false
+          num_extras_ -= 1 if @cur_expect_m
+          if num_extras_ > 0
+            raise Errors::ParseError, "Found #{extra_.size+2} coordinates, which is too many for this factory."
+          end
         else
-          if expect_z_
-            _expect_token_type(::Numeric)
-            extra_ << @cur_token
-            _next_token
+          if @cur_factory_support_z
+            if @cur_expect_z
+              _expect_token_type(::Numeric)
+              extra_ << @cur_token
+              _next_token
+            else
+              extra_ << 0
+            end
           end
-          if expect_m_
-            _expect_token_type(::Numeric)
-            extra_ << @cur_token
-            _next_token
+          if @cur_factory_support_m
+            if @cur_expect_m
+              _expect_token_type(::Numeric)
+              extra_ << @cur_token
+              _next_token
+            else
+              extra_ << 0
+            end
           end
         end
         @cur_factory.point(x_, y_, *extra_)
       end
       
       
-      def _parse_point(expect_z_, expect_m_, convert_empty_=false)  # :nodoc:
+      def _parse_point(convert_empty_=false)  # :nodoc:
         if convert_empty_ && @cur_token == 'empty'
           point_ = @cur_factory.multi_point([])
         else
           _expect_token_type(:begin)
           _next_token
-          point_ = _parse_coords(expect_z_, expect_m_)
+          point_ = _parse_coords
           _expect_token_type(:end)
         end
         _next_token
@@ -171,13 +309,13 @@ module RGeo
       end
       
       
-      def _parse_line_string(expect_z_, expect_m_)  # :nodoc:
+      def _parse_line_string  # :nodoc:
         points_ = []
         if @cur_token != 'empty'
           _expect_token_type(:begin)
           _next_token
           loop do
-            points_ << _parse_coords(expect_z_, expect_m_)
+            points_ << _parse_coords
             break if @cur_token == :end
             _expect_token_type(:comma)
             _next_token
@@ -188,19 +326,19 @@ module RGeo
       end
       
       
-      def _parse_polygon(expect_z_, expect_m_)  # :nodoc:
+      def _parse_polygon  # :nodoc:
         inner_rings_ = []
         if @cur_token == 'empty'
           outer_ring_ = @cur_factory.linear_ring([])
         else
           _expect_token_type(:begin)
           _next_token
-          outer_ring_ = _parse_line_string(expect_z_, expect_m_)
+          outer_ring_ = _parse_line_string
           loop do
             break if @cur_token == :end
             _expect_token_type(:comma)
             _next_token
-            inner_rings_ << _parse_line_string(expect_z_, expect_m_)
+            inner_rings_ << _parse_line_string
           end
         end
         _next_token
@@ -208,13 +346,13 @@ module RGeo
       end
       
       
-      def _parse_geometry_collection(expect_z_, expect_m_)  # :nodoc:
+      def _parse_geometry_collection  # :nodoc:
         geometries_ = []
         if @cur_token != 'empty'
           _expect_token_type(:begin)
           _next_token
           loop do
-            geometries_ << _parse_type_tag(expect_z_, expect_m_)
+            geometries_ << _parse_type_tag
             break if @cur_token == :end
             _expect_token_type(:comma)
             _next_token
@@ -225,13 +363,13 @@ module RGeo
       end
       
       
-      def _parse_multi_point(expect_z_, expect_m_)  # :nodoc:
+      def _parse_multi_point  # :nodoc:
         points_ = []
         if @cur_token != 'empty'
           _expect_token_type(:begin)
           _next_token
           loop do
-            points_ << _parse_point(expect_z_, expect_m_)
+            points_ << _parse_point
             break if @cur_token == :end
             _expect_token_type(:comma)
             _next_token
@@ -242,13 +380,13 @@ module RGeo
       end
       
       
-      def _parse_multi_line_string(expect_z_, expect_m_)  # :nodoc:
+      def _parse_multi_line_string  # :nodoc:
         line_strings_ = []
         if @cur_token != 'empty'
           _expect_token_type(:begin)
           _next_token
           loop do
-            line_strings_ << _parse_line_string(expect_z_, expect_m_)
+            line_strings_ << _parse_line_string
             break if @cur_token == :end
             _expect_token_type(:comma)
             _next_token
@@ -259,13 +397,13 @@ module RGeo
       end
       
       
-      def _parse_multi_polygon(expect_z_, expect_m_)  # :nodoc:
+      def _parse_multi_polygon  # :nodoc:
         polygons_ = []
         if @cur_token != 'empty'
           _expect_token_type(:begin)
           _next_token
           loop do
-            polygons_ << _parse_polygon(expect_z_, expect_m_)
+            polygons_ << _parse_polygon
             break if @cur_token == :end
             _expect_token_type(:comma)
             _next_token
@@ -282,6 +420,12 @@ module RGeo
       end
       
       
+      def _clean_scanner  # :nodoc:
+        @_scanner = nil
+        @cur_token = nil
+      end
+      
+      
       def _expect_token_type(type_)  # :nodoc:
         unless type_ === @cur_token
           raise Errors::ParseError, "#{type_.inspect} expected but #{@cur_token.inspect} found."