rgeo 0.2.8 → 0.2.9

data/lib/rgeo/wkrep/wkt_generator.rb

@@ -95,44 +95,22 @@ module RGeo
         @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.
@@ -181,19 +159,19 @@ module RGeo
           end
         end
         if type_ == Feature::Point
-          tag_ + _generate_point(obj_)
+          "#{tag_} #{_generate_point(obj_)}"
         elsif type_.subtype_of?(Feature::LineString)
-          tag_ + _generate_line_string(obj_)
+          "#{tag_} #{_generate_line_string(obj_)}"
         elsif type_ == Feature::Polygon
-          tag_ + _generate_polygon(obj_)
+          "#{tag_} #{_generate_polygon(obj_)}"
         elsif type_ == Feature::GeometryCollection
-          tag_ + _generate_geometry_collection(obj_)
+          "#{tag_} #{_generate_geometry_collection(obj_)}"
         elsif type_ == Feature::MultiPoint
-          tag_ + _generate_multi_point(obj_)
+          "#{tag_} #{_generate_multi_point(obj_)}"
         elsif type_ == Feature::MultiLineString
-          tag_ + _generate_multi_line_string(obj_)
+          "#{tag_} #{_generate_multi_line_string(obj_)}"
         elsif type_ == Feature::MultiPolygon
-          tag_ + _generate_multi_polygon(obj_)
+          "#{tag_} #{_generate_multi_polygon(obj_)}"
         else
           raise Error::ParseError, "Unrecognized geometry type: #{type_}"
         end
@@ -213,56 +191,56 @@ module RGeo
       end
       
       
-      def _generate_line_string(obj_, contained_=false)  # :nodoc:
+      def _generate_line_string(obj_)  # :nodoc:
         if obj_.is_empty?
-          contained_ ? '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_, contained_=false)  # :nodoc:
+      def _generate_polygon(obj_)  # :nodoc:
         if obj_.is_empty?
-          contained_ ? 'EMPTY' : ' EMPTY'
+          'EMPTY'
         else
-          "#{@begin_bracket}#{([_generate_line_string(obj_.exterior_ring, true)] + obj_.interior_rings.map{ |r_| _generate_line_string(r_, true) }).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:
         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:
         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:
         if obj_.is_empty?
-          " EMPTY"
+          'EMPTY'
         else
-          "#{@begin_bracket}#{obj_.map{ |f_| _generate_line_string(f_, true) }.join(',')}#{@end_bracket}"
+          "#{@begin_bracket}#{obj_.map{ |f_| _generate_line_string(f_) }.join(', ')}#{@end_bracket}"
         end
       end
       
       
       def _generate_multi_polygon(obj_)  # :nodoc:
         if obj_.is_empty?
-          " EMPTY"
+          'EMPTY'
         else
-          "#{@begin_bracket}#{obj_.map{ |f_| _generate_polygon(f_, true) }.join(',')}#{@end_bracket}"
+          "#{@begin_bracket}#{obj_.map{ |f_| _generate_polygon(f_) }.join(', ')}#{@end_bracket}"
         end
       end
       

data/lib/rgeo/wkrep/wkt_parser.rb

@@ -88,7 +88,16 @@ module RGeo
       # documentation for the options that can be passed.
       
       def initialize(factory_generator_=nil, opts_={})
-        self.factory_generator = factory_generator_
+        if factory_generator_.kind_of?(Feature::Factory::Instance)
+          @factory_generator = Feature::FactoryGenerator.single(factory_generator_)
+          @exact_factory = factory_generator_
+        elsif factory_generator_.respond_to?(:call)
+          @factory_generator = factory_generator_
+          @exact_factory = nil
+        else
+          @factory_generator = Cartesian.method(:preferred_factory)
+          @exact_factory = nil
+        end
         @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
@@ -108,70 +117,30 @@ module RGeo
         @exact_factory
       end
       
-      # Sets the factory_generator. See WKTParser for details.
-      def factory_generator=(value_)
-        if value_.kind_of?(Feature::Factory::Instance)
-          @factory_generator = Feature::FactoryGenerator.single(value_)
-          @exact_factory = value_
-        elsif value_.respond_to?(:call)
-          @factory_generator = value_
-          @exact_factory = nil
-        else
-          @factory_generator = Cartesian.method(:preferred_factory)
-          @exact_factory = nil
-        end
-      end
-      
-      # Sets the factory_generator to the given block.
-      # See WKTParser for details.
-      def to_generate_factory(&block_)
-        self.factory_generator = 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.
       

data/test/common/point_tests.rb

@@ -62,7 +62,7 @@ module RGeo
         
         
         def test_wkt_creation
-          point1_ = @factory.parse_wkt('POINT(21 -22)')
+          point1_ = @factory.parse_wkt('Point (21 -22)')
           assert_equal(21, point1_.x)
           assert_equal(-22, point1_.y)
         end
@@ -106,6 +106,12 @@ module RGeo
         end
         
         
+        def test_as_text
+          point_ = @factory.point(11, 12)
+          assert_equal('POINT (11.0 12.0)', point_.as_text)
+        end
+        
+        
         def test_as_text_wkt_round_trip
           point1_ = @factory.point(11, 12)
           text_ = point1_.as_text

data/test/geos/tc_parsing_unparsing.rb

@@ -0,0 +1,80 @@
+# -----------------------------------------------------------------------------
+# 
+# Tests for the GEOS point implementation
+# 
+# -----------------------------------------------------------------------------
+# Copyright 2010 Daniel Azuma
+# 
+# All rights reserved.
+# 
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are met:
+# 
+# * Redistributions of source code must retain the above copyright notice,
+#   this list of conditions and the following disclaimer.
+# * Redistributions in binary form must reproduce the above copyright notice,
+#   this list of conditions and the following disclaimer in the documentation
+#   and/or other materials provided with the distribution.
+# * Neither the name of the copyright holder, nor the names of any other
+#   contributors to this software, may be used to endorse or promote products
+#   derived from this software without specific prior written permission.
+# 
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+# ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+# POSSIBILITY OF SUCH DAMAGE.
+# -----------------------------------------------------------------------------
+;
+
+
+require 'test/unit'
+require 'rgeo'
+
+
+module RGeo
+  module Tests  # :nodoc:
+    module Geos  # :nodoc:
+      
+      class TestParsingUnparsing < ::Test::Unit::TestCase  # :nodoc:
+        
+        
+        def test_wkt_generator_default_floating_point
+          # Bug report GH-4
+          factory_ = ::RGeo::Geos.factory
+          point_ = factory_.point(111.99, -40.37)
+          assert_equal('POINT (111.99 -40.37)', point_.as_text)
+        end
+        
+        
+        def test_wkt_generator_downcase
+          factory_ = ::RGeo::Geos.factory(:wkt_generator => {:convert_case => :lower})
+          point_ = factory_.point(1, 1)
+          assert_equal('point (1.0 1.0)', point_.as_text)
+        end
+        
+        
+        def test_wkt_generator_geos
+          factory_ = ::RGeo::Geos.factory(:wkt_generator => :geos)
+          point_ = factory_.point(1, 1)
+          assert_equal('POINT (1.0000000000000000 1.0000000000000000)', point_.as_text)
+        end
+        
+        
+        def test_wkt_parser_default_with_non_geosable_input
+          factory_ = ::RGeo::Geos.factory
+          assert_not_nil(factory_.parse_wkt('Point (1 1)'))
+        end
+        
+        
+      end
+      
+    end
+  end
+end if ::RGeo::Geos.supported?

data/test/wkrep/tc_wkb_parser.rb

@@ -45,9 +45,18 @@ module RGeo
       class TestWKBParser < ::Test::Unit::TestCase  # :nodoc:
         
         
-        def test_point_2d_xdr
+        def test_point_2d_xdr_hex
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse_hex('00000000013ff00000000000004000000000000000')
+          obj_ = parser_.parse('00000000013ff00000000000004000000000000000')
+          assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
+          assert_equal(1, obj_.x)
+          assert_equal(2, obj_.y)
+        end
+        
+        
+        def test_point_2d_xdr_binary
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse(['00000000013ff00000000000004000000000000000'].pack('H*'))
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(1, obj_.x)
           assert_equal(2, obj_.y)
@@ -56,7 +65,7 @@ module RGeo
         
         def test_point_2d_ndr
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse_hex('0101000000000000000000f03f0000000000000040')
+          obj_ = parser_.parse('0101000000000000000000f03f0000000000000040')
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(1, obj_.x)
           assert_equal(2, obj_.y)
@@ -66,7 +75,7 @@ module RGeo
         def test_point_with_ewkb_z
           factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
           parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true)
-          obj_ = parser_.parse_hex('00800000013ff000000000000040000000000000004008000000000000')
+          obj_ = parser_.parse('00800000013ff000000000000040000000000000004008000000000000')
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(3, obj_.z)
           assert_nil(obj_.m)
@@ -76,7 +85,7 @@ module RGeo
         def test_point_with_ewkb_m
           factory_ = ::RGeo::Cartesian.preferred_factory(:has_m_coordinate => true)
           parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true)
-          obj_ = parser_.parse_hex('00400000013ff000000000000040000000000000004008000000000000')
+          obj_ = parser_.parse('00400000013ff000000000000040000000000000004008000000000000')
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(3, obj_.m)
           assert_nil(obj_.z)
@@ -86,7 +95,7 @@ module RGeo
         def test_point_with_ewkb_zm
           factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true, :has_m_coordinate => true)
           parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true)
-          obj_ = parser_.parse_hex('00c00000013ff0000000000000400000000000000040080000000000004010000000000000')
+          obj_ = parser_.parse('00c00000013ff0000000000000400000000000000040080000000000004010000000000000')
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(3, obj_.z)
           assert_equal(4, obj_.m)
@@ -96,7 +105,7 @@ module RGeo
         def test_point_with_wkb12_z
           factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
           parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_wkb12 => true)
-          obj_ = parser_.parse_hex('00000003e93ff000000000000040000000000000004008000000000000')
+          obj_ = parser_.parse('00000003e93ff000000000000040000000000000004008000000000000')
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(3, obj_.z)
           assert_nil(obj_.m)
@@ -106,7 +115,7 @@ module RGeo
         def test_point_with_wkb12_m
           factory_ = ::RGeo::Cartesian.preferred_factory(:has_m_coordinate => true)
           parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_wkb12 => true)
-          obj_ = parser_.parse_hex('00000007d13ff000000000000040000000000000004008000000000000')
+          obj_ = parser_.parse('00000007d13ff000000000000040000000000000004008000000000000')
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(3, obj_.m)
           assert_nil(obj_.z)
@@ -116,7 +125,7 @@ module RGeo
         def test_point_with_wkb12_zm
           factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true, :has_m_coordinate => true)
           parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_wkb12 => true)
-          obj_ = parser_.parse_hex('0000000bb93ff0000000000000400000000000000040080000000000004010000000000000')
+          obj_ = parser_.parse('0000000bb93ff0000000000000400000000000000040080000000000004010000000000000')
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(3, obj_.z)
           assert_equal(4, obj_.m)
@@ -127,7 +136,7 @@ module RGeo
           factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
           parser_ = ::RGeo::WKRep::WKBParser.new(factory_)
           assert_raise(::RGeo::Error::ParseError) do
-            obj_ = parser_.parse_hex('00000003e93ff000000000000040000000000000004008000000000000')
+            obj_ = parser_.parse('00000003e93ff000000000000040000000000000004008000000000000')
           end
         end
         
@@ -136,18 +145,17 @@ module RGeo
           factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
           parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_wkb12 => true)
           assert_raise(::RGeo::Error::ParseError) do
-            obj_ = parser_.parse_hex('00000003e93ff00000000000004000000000000000')
+            obj_ = parser_.parse('00000003e93ff00000000000004000000000000000')
           end
         end
         
         
         def test_point_with_ewkb_z_and_srid
-          factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true)
-          parser_.to_generate_factory do |config_|
+          factory_generator_ = ::Proc.new do |config_|
             ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true, :srid => config_[:srid])
           end
-          obj_ = parser_.parse_hex('00a0000001000003e83ff000000000000040000000000000004008000000000000')
+          parser_ = ::RGeo::WKRep::WKBParser.new(factory_generator_, :support_ewkb => true)
+          obj_ = parser_.parse('00a0000001000003e83ff000000000000040000000000000004008000000000000')
           assert_equal(::RGeo::Feature::Point, obj_.geometry_type)
           assert_equal(3, obj_.z)
           assert_nil(obj_.m)
@@ -157,7 +165,7 @@ module RGeo
         
         def test_linestring_basic
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse_hex('0000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
+          obj_ = parser_.parse('0000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
           assert_equal(::RGeo::Feature::LineString, obj_.geometry_type)
           assert_equal(3, obj_.num_points)
           assert_equal(1, obj_.point_n(0).x)
@@ -168,7 +176,7 @@ module RGeo
         def test_linestring_with_ewkb_z
           factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
           parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true)
-          obj_ = parser_.parse_hex('0080000002000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
+          obj_ = parser_.parse('0080000002000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
           assert_equal(::RGeo::Feature::LineString, obj_.geometry_type)
           assert_equal(2, obj_.num_points)
           assert_equal(1, obj_.point_n(0).x)
@@ -177,12 +185,11 @@ module RGeo
         
         
         def test_linestring_with_ewkb_z_and_srid
-          factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
-          parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true)
-          parser_.to_generate_factory do |config_|
+          factory_generator_ = ::Proc.new do |config_|
             ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true, :srid => config_[:srid])
           end
-          obj_ = parser_.parse_hex('00a0000002000003e8000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
+          parser_ = ::RGeo::WKRep::WKBParser.new(factory_generator_, :support_ewkb => true)
+          obj_ = parser_.parse('00a0000002000003e8000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
           assert_equal(::RGeo::Feature::LineString, obj_.geometry_type)
           assert_equal(2, obj_.num_points)
           assert_equal(1, obj_.point_n(0).x)
@@ -194,7 +201,7 @@ module RGeo
         def test_linestring_with_wkb12_z
           factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
           parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_wkb12 => true)
-          obj_ = parser_.parse_hex('00000003ea000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
+          obj_ = parser_.parse('00000003ea000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
           assert_equal(::RGeo::Feature::LineString, obj_.geometry_type)
           assert_equal(2, obj_.num_points)
           assert_equal(1, obj_.point_n(0).x)
@@ -204,7 +211,7 @@ module RGeo
         
         def test_linestring_empty
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse_hex('000000000200000000')
+          obj_ = parser_.parse('000000000200000000')
           assert_equal(::RGeo::Feature::LineString, obj_.geometry_type)
           assert_equal(0, obj_.num_points)
         end
@@ -212,7 +219,7 @@ module RGeo
         
         def test_polygon_basic
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse_hex('000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000')
+          obj_ = parser_.parse('000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000')
           assert_equal(::RGeo::Feature::Polygon, obj_.geometry_type)
           assert_equal(4, obj_.exterior_ring.num_points)
           assert_equal(1, obj_.exterior_ring.point_n(0).x)
@@ -222,7 +229,7 @@ module RGeo
         
         def test_polygon_empty
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse_hex('000000000300000000')
+          obj_ = parser_.parse('000000000300000000')
           assert_equal(::RGeo::Feature::Polygon, obj_.geometry_type)
           assert_equal(0, obj_.exterior_ring.num_points)
         end
@@ -230,7 +237,7 @@ module RGeo
         
         def test_multipoint_basic
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse_hex('00000000040000000200000000013ff00000000000004000000000000000000000000140080000000000004010000000000000')
+          obj_ = parser_.parse('00000000040000000200000000013ff00000000000004000000000000000000000000140080000000000004010000000000000')
           assert_equal(::RGeo::Feature::MultiPoint, obj_.geometry_type)
           assert_equal(2, obj_.num_geometries)
           assert_equal(1, obj_[0].x)
@@ -240,7 +247,7 @@ module RGeo
         
         def test_multipoint_mixed_byte_order
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse_hex('0000000004000000020101000000000000000000f03f0000000000000040000000000140080000000000004010000000000000')
+          obj_ = parser_.parse('0000000004000000020101000000000000000000f03f0000000000000040000000000140080000000000004010000000000000')
           assert_equal(::RGeo::Feature::MultiPoint, obj_.geometry_type)
           assert_equal(2, obj_.num_geometries)
           assert_equal(1, obj_[0].x)
@@ -251,7 +258,7 @@ module RGeo
         def test_multipoint_with_ewkb_z
           factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
           parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true)
-          obj_ = parser_.parse_hex('00800000040000000200800000013ff0000000000000400000000000000040140000000000000080000001400800000000000040100000000000004018000000000000')
+          obj_ = parser_.parse('00800000040000000200800000013ff0000000000000400000000000000040140000000000000080000001400800000000000040100000000000004018000000000000')
           assert_equal(::RGeo::Feature::MultiPoint, obj_.geometry_type)
           assert_equal(2, obj_.num_geometries)
           assert_equal(1, obj_[0].x)
@@ -266,14 +273,14 @@ module RGeo
           factory_ = ::RGeo::Cartesian.preferred_factory(:has_z_coordinate => true)
           parser_ = ::RGeo::WKRep::WKBParser.new(factory_, :support_ewkb => true)
           assert_raise(::RGeo::Error::ParseError) do
-            obj_ = parser_.parse_hex('00800000040000000200800000013ff000000000000040000000000000004014000000000000000000000140080000000000004010000000000000')
+            obj_ = parser_.parse('00800000040000000200800000013ff000000000000040000000000000004014000000000000000000000140080000000000004010000000000000')
           end
         end
         
         
         def test_multipoint_empty
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse_hex('000000000400000000')
+          obj_ = parser_.parse('000000000400000000')
           assert_equal(::RGeo::Feature::MultiPoint, obj_.geometry_type)
           assert_equal(0, obj_.num_geometries)
         end
@@ -281,7 +288,7 @@ module RGeo
         
         def test_multilinestring_basic
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse_hex('0000000005000000020000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000000000000200000002bff0000000000000c000000000000000c008000000000000c010000000000000')
+          obj_ = parser_.parse('0000000005000000020000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000000000000200000002bff0000000000000c000000000000000c008000000000000c010000000000000')
           assert_equal(::RGeo::Feature::MultiLineString, obj_.geometry_type)
           assert_equal(2, obj_.num_geometries)
           assert_equal(1, obj_[0].point_n(0).x)
@@ -292,14 +299,14 @@ module RGeo
         def test_multilinestring_wrong_element_type
           parser_ = ::RGeo::WKRep::WKBParser.new
           assert_raise(::RGeo::Error::ParseError) do
-            obj_ = parser_.parse_hex('0000000005000000020000000002000000033ff00000000000004000000000000000400800000000000040100000000000004014000000000000401800000000000000000000013ff00000000000004000000000000000')
+            obj_ = parser_.parse('0000000005000000020000000002000000033ff00000000000004000000000000000400800000000000040100000000000004014000000000000401800000000000000000000013ff00000000000004000000000000000')
           end
         end
         
         
         def test_multilinestring_empty
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse_hex('000000000500000000')
+          obj_ = parser_.parse('000000000500000000')
           assert_equal(::RGeo::Feature::MultiLineString, obj_.geometry_type)
           assert_equal(0, obj_.num_geometries)
         end
@@ -307,7 +314,7 @@ module RGeo
         
         def test_multipolygon_basic
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse_hex('000000000600000002000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000000000000300000000')
+          obj_ = parser_.parse('000000000600000002000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000000000000300000000')
           assert_equal(::RGeo::Feature::MultiPolygon, obj_.geometry_type)
           assert_equal(2, obj_.num_geometries)
           assert_equal(4, obj_[0].exterior_ring.num_points)
@@ -319,7 +326,7 @@ module RGeo
         
         def test_multipolygon_empty
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse_hex('000000000600000000')
+          obj_ = parser_.parse('000000000600000000')
           assert_equal(::RGeo::Feature::MultiPolygon, obj_.geometry_type)
           assert_equal(0, obj_.num_geometries)
         end
@@ -327,7 +334,7 @@ module RGeo
         
         def test_collection_basic
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse_hex('0000000007000000020000000002000000033ff0000000000000400000000000000040080000000000004010000000000000401400000000000040180000000000000000000001bff0000000000000c000000000000000')
+          obj_ = parser_.parse('0000000007000000020000000002000000033ff0000000000000400000000000000040080000000000004010000000000000401400000000000040180000000000000000000001bff0000000000000c000000000000000')
           assert_equal(::RGeo::Feature::GeometryCollection, obj_.geometry_type)
           assert_equal(2, obj_.num_geometries)
           assert_equal(::RGeo::Feature::LineString, obj_[0].geometry_type)
@@ -340,7 +347,7 @@ module RGeo
         
         def test_collection_empty
           parser_ = ::RGeo::WKRep::WKBParser.new
-          obj_ = parser_.parse_hex('000000000700000000')
+          obj_ = parser_.parse('000000000700000000')
           assert_equal(::RGeo::Feature::GeometryCollection, obj_.geometry_type)
           assert_equal(0, obj_.num_geometries)
         end