rgeo 0.1.15 → 0.1.16

data/History.rdoc

@@ -1,3 +1,12 @@
+=== 0.1.16 / 2010-11-18
+
+* Test coverage for WKB generator and parser; fixed a few bugs.
+* Eliminated the hard dependency on the JSON gem, and allow configuration of GeoJSON with an alternate JSON parser such as YAJL or ActiveSupport.
+* API CHANGE: geo factory is now a hash option in GeoJSON, and is now optional.
+* GeoJSON now handles Z and M coordinates, according to the capabilities of the geo factory.
+* GeoJSON feature objects can now handle null geometry and null properties, per the spec.
+* Factory::cast now optionally lets you pass the parameters as a hash.
+
 === 0.1.15 / 2010-11-08
 
 * Cleanup, fixes, documentation, and partial test coverage in the WKT/WKB implementations.

data/README.rdoc

@@ -76,6 +76,7 @@ yet complete. These include:
 * Some operations on SimpleCartesian and SimpleSpherical.
 * Rails (ActiveRecord or ActiveModel) integration.
 * Other third-party integration, including possibly SimpleGeo.
+* Support for bbox and crs elements of GeoJSON.
 * Support for additional formats such as ESRI shapefiles.
 * JRuby support via JTS integration.
 * Rubinius support for Geos integration.

data/Version

@@ -1 +1 @@
-0.1.15
+0.1.16

data/lib/rgeo/cartesian/factory.rb

@@ -90,14 +90,14 @@ module RGeo
       # See ::RGeo::Features::Factory#parse_wkt
       
       def parse_wkt(str_)
-        ::RGeo::WKRep::WKTParser.new(:default_factory => self).parse(str_)
+        WKRep::WKTParser.new(:default_factory => self).parse(str_)
       end
       
       
       # See ::RGeo::Features::Factory#parse_wkb
       
       def parse_wkb(str_)
-        ::RGeo::WKRep::WKBParser.new(:default_factory => self).parse(str_)
+        WKRep::WKBParser.new(:default_factory => self).parse(str_)
       end
       
       

data/lib/rgeo/features/factory.rb

@@ -44,13 +44,14 @@ module RGeo
     # methods as a standard way to create features.
     # 
     # If the implementation is unable to create the given feature,
-    # it should return nil.
+    # it should generally return nil. Implementations may also choose to
+    # raise an exception on failure.
     # 
     # Some implementations may extend this interface to provide facilities
-    # for creating additional objects according to the features handled
-    # by that implementation. Examples might include higher-dimensional
-    # coordinates or additional subclasses not explicitly required by the
-    # Simple Features Specification.
+    # for creating additional objects according to the capabilities
+    # provided by that implementation. Examples might include
+    # higher-dimensional coordinates or additional subclasses not
+    # explicitly required by the Simple Features Specification.
     # 
     # Factory is defined as a module and is provided primarily for the
     # sake of documentation. Implementations need not necessarily include

data/lib/rgeo/features/types.rb

@@ -101,13 +101,28 @@ module RGeo
       
       # Cast the given object according to the given parameters.
       # 
-      # You may optionally pass a factory, a feature type, and the value
-      # <tt>:force_new</tt> as the parameters. The given object will be
-      # casted into the given factory and feature type, if possible.
+      # You may optionally pass a factory, a feature type, the value
+      # <tt>:force_new</tt>, and the value <tt>:keep_subtype</tt> as the
+      # parameters. You may also pass the parameters as a hash, with the
+      # keys <tt>:factory</tt>, <tt>:type</tt>, <tt>:force_new</tt> and
+      # <tt>:keep_subtype</tt>.
+      # 
+      # The given object will be casted into the given factory and
+      # feature type, if possible.
       # If the cast is not possible to accomplish, nil is returned.
       # If the factory or type is not provided, or is the same as the
       # object's current attribute, that attribute is not modified.
       # 
+      # Normally, casting to a particular type always casts strictly to
+      # that type, even if the old type is a subtype of the new type.
+      # You can cause cast to retain the subtype by passing
+      # <tt>:keep_subtype</tt> as one of the parameters. For example,
+      # casting a LinearRing to a LineString will normally yield a
+      # LineString. However, if you specify <tt>:keep_subtype</tt>, the
+      # casted object will remain a LinearRing. You cannot cast to a
+      # non-instantiable type (such as Curve) without specifying
+      # <tt>:keep_subtype</tt>.
+      # 
       # Normally, if neither the factory nor the type are set to be
       # modified, the original object is returned. However, you may cause
       # cast to return a duplicate of the original object by passing
@@ -135,6 +150,11 @@ module RGeo
             force_new_ = param_
           when :keep_subtype
             keep_subtype_ = param_
+          when ::Hash
+            nfactory_ = param_[:factory] || nfactory_
+            ntype_ = param_[:type] || ntype_
+            force_new_ = param_[:force_new] if param_.include?(:force_new)
+            keep_subtype_ = param_[:keep_subtype] if param_.include?(:keep_subtype)
           end
         end
         

data/lib/rgeo/geo_json/coder.rb

@@ -34,9 +34,6 @@
 ;
 
 
-require 'json'
-
-
 module RGeo
   
   module GeoJSON
@@ -51,14 +48,62 @@ module RGeo
       
       
       # Create a new coder settings object. The geo factory is passed as
-      # a required argument. The entity factory is optional. To provide
-      # one, pass an option with key <tt>:entity_factory</tt>. It defaults
-      # to the default RGeo::GeoJSON::EntityFactory, which generates
-      # objects of type RGeo::GeoJSON::Feature or RGeo::GeoJSON::FeatureCollection.
-      
-      def initialize(geo_factory_, opts_={})
-        @geo_factory = geo_factory_
+      # a required argument.
+      # 
+      # Options include:
+      # 
+      # <tt>:geo_factory</tt>::
+      #   Specifies the geo factory to use to create geometry objects.
+      #   Defaults to the preferred cartesian factory.
+      # <tt>:entity_factory</tt>::
+      #   Specifies an entity factory, which lets you override the types
+      #   of GeoJSON entities that are created. It defaults to the default
+      #   RGeo::GeoJSON::EntityFactory, which generates objects of type
+      #   RGeo::GeoJSON::Feature or RGeo::GeoJSON::FeatureCollection.
+      #   See RGeo::GeoJSON::EntityFactory for more information.
+      # <tt>:json_parser</tt>::
+      #   Specifies a JSON parser to use when decoding a String or IO
+      #   object. The value may be a Proc object taking the string as the
+      #   sole argument and returning the JSON hash, or it may be one of
+      #   the special values <tt>:json</tt>, <tt>:yajl</tt>, or
+      #   <tt>:active_support</tt>. Setting one of those special values
+      #   will require the corresponding library to be available. The
+      #   default is <tt>:json</tt>, which is present in the standard
+      #   library in Ruby 1.9, but requires the "json" gem in Ruby 1.8.
+      #   If the specified parser is not available, then decode will not
+      #   accept a String or IO object; it will require a Hash.
+      
+      def initialize(opts_={})
+        @geo_factory = opts_[:geo_factory] || ::RGeo::Cartesian.preferred_factory
         @entity_factory = opts_[:entity_factory] || EntityFactory.instance
+        @json_parser = opts_[:json_parser] || :json
+        case @json_parser
+        when :json
+          begin
+            require 'json'
+            @json_parser = ::Proc.new{ |str_| ::JSON.parse(str_) }
+          rescue ::LoadError
+          end
+        when :yajl
+          begin
+            require 'yajl'
+            @json_parser = ::Proc.new{ |str_| ::Yajl::Parser.new.parse(str_) }
+          rescue ::LoadError
+          end
+        when :active_support
+          begin
+            require 'active_support/json'
+            @json_parser = ::Proc.new{ |str_| ::ActiveSupport::JSON.decode(str_) }
+          rescue ::LoadError
+          end
+        when ::Proc
+          # Leave as is
+        else
+          raise ::ArgumentError, "Unrecognzied json_parser: #{@json_parser.inspect}"
+        end
+        @num_coordinates = 2
+        @num_coordinates += 1 if @geo_factory.has_capability?(:z_coordinate)
+        @num_coordinates += 1 if @geo_factory.has_capability?(:m_coordinate)
       end
       
       
@@ -82,13 +127,14 @@ module RGeo
       
       # Decode an object from GeoJSON. The input may be a JSON hash, a
       # String, or an IO object from which to read the JSON string.
+      # If an error occurs, nil is returned.
       
       def decode(input_)
         if input_.kind_of?(::IO)
           input_ = input_.read rescue nil
         end
         if input_.kind_of?(::String)
-          input_ = ::JSON.parse(input_) rescue nil
+          input_ = @json_parser.call(input_) rescue nil
         end
         unless input_.kind_of?(::Hash)
           return nil
@@ -139,42 +185,57 @@ module RGeo
       end
       
       
-      def _encode_geometry(object_)  # :nodoc:
+      def _encode_geometry(object_, point_encoder_=nil)  # :nodoc:
+        unless point_encoder_
+          if object_.factory.has_capability?(:z_coordinate)
+            if object_.factory.has_capability?(:m_coordinate)
+              point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y, p_.z, p_.m] }
+            else
+              point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y, p_.z] }
+            end
+          else
+            if object_.factory.has_capability?(:m_coordinate)
+              point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y, p_.m] }
+            else
+              point_encoder_ = ::Proc.new{ |p_| [p_.x, p_.y] }
+            end
+          end
+        end
         case object_
         when Features::Point
           {
             'type' => 'Point',
-            'coordinates' => [object_.x, object_.y],
+            'coordinates' => point_encoder_.call(object_),
           }
         when Features::LineString
           {
             'type' => 'LineString',
-            'coordinates' => object_.points.map{ |p_| [p_.x, p_.y] },
+            'coordinates' => object_.points.map(&point_encoder_),
           }
         when Features::Polygon
           {
             'type' => 'Polygon',
-            'coordinates' => [object_.exterior_ring.points.map{ |p_| [p_.x, p_.y] }] + object_.interior_rings.map{ |r_| r_.points.map{ |p_| [p_.x, p_.y] } }
+            'coordinates' => [object_.exterior_ring.points.map(&point_encoder_)] + object_.interior_rings.map{ |r_| r_.points.map(&point_encoder_) }
           }
         when Features::MultiPoint
           {
             'type' => 'MultiPoint',
-            'coordinates' => object_.map{ |p_| [p_.x, p_.y] },
+            'coordinates' => object_.map(&point_encoder_),
           }
         when Features::MultiLineString
           {
             'type' => 'MultiLineString',
-            'coordinates' => object_.map{ |ls_| ls_.points.map{ |p_| [p_.x, p_.y] } },
+            'coordinates' => object_.map{ |ls_| ls_.points.map(&point_encoder_) },
           }
         when Features::MultiPolygon
           {
             'type' => 'MultiPolygon',
-            'coordinates' => object_.map{ |poly_| [poly_.exterior_ring.points.map{ |p_| [p_.x, p_.y] }] + poly_.interior_rings.map{ |r_| r_.points.map{ |p_| [p_.x, p_.y] } } },
+            'coordinates' => object_.map{ |poly_| [poly_.exterior_ring.points.map(&point_encoder_)] + poly_.interior_rings.map{ |r_| r_.points.map(&point_encoder_) } },
           }
         when Features::GeometryCollection
           {
             'type' => 'GeometryCollection',
-            'geometries' => object_.map{ |geom_| _encode_geometry(geom_) },
+            'geometries' => object_.map{ |geom_| _encode_geometry(geom_, point_encoder_) },
           }
         else
           nil
@@ -183,12 +244,12 @@ module RGeo
       
       
       def _decode_feature(input_)  # :nodoc:
-        geometry_ = _decode_geometry(input_['geometry'])
+        geometry_ = input_['geometry']
         if geometry_
-          @entity_factory.feature(geometry_, input_['id'], input_['properties'])
-        else
-          nil
+          geometry_ = _decode_geometry(geometry_)
+          return nil unless geometry_
         end
+        @entity_factory.feature(geometry_, input_['id'], input_['properties'])
       end
       
       
@@ -228,7 +289,7 @@ module RGeo
       
       def _decode_point_coords(point_coords_)  # :nodoc:
         return nil unless point_coords_.kind_of?(::Array)
-        @geo_factory.point(point_coords_[0].to_f, point_coords_[1].to_f) rescue nil
+        @geo_factory.point(*(point_coords_[0...@num_coordinates].map{ |c_| c_.to_f })) rescue nil
       end
       
       

data/lib/rgeo/geo_json/entities.rb

@@ -63,7 +63,7 @@ module RGeo
       
       
       def inspect  # :nodoc:
-        "#<#{self.class}:0x#{object_id.to_s(16)} id=#{@id.inspect} geom=#{@geometry.as_text.inspect}>"
+        "#<#{self.class}:0x#{object_id.to_s(16)} id=#{@id.inspect} geom=#{@geometry ? @geometry.as_text.inspect : 'nil'}>"
       end
       
       def to_s  # :nodoc:
@@ -95,7 +95,7 @@ module RGeo
       end
       
       
-      # Returns the geometry contained in this feature.
+      # Returns the geometry contained in this feature, which may be nil.
       
       def geometry
         @geometry
@@ -208,10 +208,11 @@ module RGeo
       
       
       # Create and return a new feature, given geometry, ID, and
-      # properties hash.
+      # properties hash. Note that, per the GeoJSON spec, geometry and/or
+      # properties may be nil.
       
-      def feature(geometry_, id_=nil, properties_={})
-        Feature.new(geometry_, id_, properties_)
+      def feature(geometry_, id_=nil, properties_=nil)
+        Feature.new(geometry_, id_, properties_ || {})
       end
       
       

data/lib/rgeo/geo_json/interface.rb

@@ -53,23 +53,39 @@ module RGeo
       # RGeo::GeoJSON::FeatureCollection.
       
       def encode(object_, opts_={})
-        Coder.new(nil, opts_).encode(object_)
+        Coder.new(opts_).encode(object_)
       end
       
       
       # High-level convenience routine for decoding an object from GeoJSON.
       # The input may be a JSON hash, a String, or an IO object from which
-      # to read the JSON string. You must also provide the
-      # RGeo::Features::Factory to use to create geometric objects.
+      # to read the JSON string.
       # 
-      # The only option supported is <tt>:entity_factory</tt>, which lets
-      # you override the types of GeoJSON entities that can be created.
-      # See RGeo::GeoJSON::EntityFactory for more information. By default,
-      # decode generates objects of type RGeo::GeoJSON::Feature and
-      # RGeo::GeoJSON::FeatureCollection.
+      # Options include:
+      # 
+      # <tt>:geo_factory</tt>::
+      #   Specifies the geo factory to use to create geometry objects.
+      #   Defaults to the preferred cartesian factory.
+      # <tt>:entity_factory</tt>::
+      #   Specifies an entity factory, which lets you override the types
+      #   of GeoJSON entities that are created. It defaults to the default
+      #   RGeo::GeoJSON::EntityFactory, which generates objects of type
+      #   RGeo::GeoJSON::Feature or RGeo::GeoJSON::FeatureCollection.
+      #   See RGeo::GeoJSON::EntityFactory for more information.
+      # <tt>:json_parser</tt>::
+      #   Specifies a JSON parser to use when decoding a String or IO
+      #   object. The value may be a Proc object taking the string as the
+      #   sole argument and returning the JSON hash, or it may be one of
+      #   the special values <tt>:json</tt>, <tt>:yajl</tt>, or
+      #   <tt>:active_support</tt>. Setting one of those special values
+      #   will require the corresponding library to be available. The
+      #   default is <tt>:json</tt>, which is present in the standard
+      #   library in Ruby 1.9, but requires the "json" gem in Ruby 1.8.
+      #   If the specified parser is not available, then decode will not
+      #   accept a String or IO object; it will require a Hash.
       
-      def decode(input_, geo_factory_, opts_={})
-        Coder.new(geo_factory_, opts_).decode(input_)
+      def decode(input_, opts_={})
+        Coder.new(opts_).decode(input_)
       end
       
       
@@ -77,14 +93,32 @@ module RGeo
       # that encapsulates encoding and decoding settings (principally the
       # RGeo::Features::Factory and the RGeo::GeoJSON::EntityFactory to be
       # used).
-      # The geo factory is a required argument. The entity factory is
-      # optional. To provide one, pass an option with key
-      # <tt>:entity_factory</tt>. It defaults to the default
-      # RGeo::GeoJSON::EntityFactory, which generates objects of type
-      # RGeo::GeoJSON::Feature or RGeo::GeoJSON::FeatureCollection.
+      # 
+      # The geo factory is a required argument. Other options include:
+      # 
+      # <tt>:geo_factory</tt>::
+      #   Specifies the geo factory to use to create geometry objects.
+      #   Defaults to the preferred cartesian factory.
+      # <tt>:entity_factory</tt>::
+      #   Specifies an entity factory, which lets you override the types
+      #   of GeoJSON entities that are created. It defaults to the default
+      #   RGeo::GeoJSON::EntityFactory, which generates objects of type
+      #   RGeo::GeoJSON::Feature or RGeo::GeoJSON::FeatureCollection.
+      #   See RGeo::GeoJSON::EntityFactory for more information.
+      # <tt>:json_parser</tt>::
+      #   Specifies a JSON parser to use when decoding a String or IO
+      #   object. The value may be a Proc object taking the string as the
+      #   sole argument and returning the JSON hash, or it may be one of
+      #   the special values <tt>:json</tt>, <tt>:yajl</tt>, or
+      #   <tt>:active_support</tt>. Setting one of those special values
+      #   will require the corresponding library to be available. The
+      #   default is <tt>:json</tt>, which is present in the standard
+      #   library in Ruby 1.9, but requires the "json" gem in Ruby 1.8.
+      #   If the specified parser is not available, then decode will not
+      #   accept a String or IO object; it will require a Hash.
       
-      def coder(geo_factory_, opts_={})
-        Coder.new(geo_factory_, opts_)
+      def coder(opts_={})
+        Coder.new(opts_)
       end
       
       

data/lib/rgeo/wkrep/wkb_generator.rb

@@ -177,7 +177,7 @@ module RGeo
           type_code_ |= 0x80000000 if @cur_has_z
           type_code_ |= 0x40000000 if @cur_has_m
           if @emit_ewkb_srid && toplevel_
-            type_code |= 0x20000000
+            type_code_ |= 0x20000000
             emit_srid_ = true
           end
         elsif @type_format == :wkb12

data/tests/tc_geojson.rb

@@ -45,7 +45,10 @@ module RGeo
       
       
       def setup
-        @geo_factory = ::RGeo::Geos.factory(:srid => 4326)
+        @geo_factory = ::RGeo::Cartesian.simple_factory(:srid => 4326)
+        @geo_factory_z = ::RGeo::Cartesian.simple_factory(:srid => 4326, :support_z_coordinate => true)
+        @geo_factory_m = ::RGeo::Cartesian.simple_factory(:srid => 4326, :support_m_coordinate => true)
+        @geo_factory_zm = ::RGeo::Cartesian.simple_factory(:srid => 4326, :support_z_coordinate => true, :support_m_coordinate => true)
         @entity_factory = ::RGeo::GeoJSON::EntityFactory.instance
       end
       
@@ -57,7 +60,40 @@ module RGeo
           'coordinates' => [10.0, 20.0],
         }
         assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-        assert(::RGeo::GeoJSON.decode(json_, @geo_factory).eql?(object_))
+        assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
+      end
+      
+      
+      def test_point_z
+        object_ = @geo_factory_z.point(10, 20, -1)
+        json_ = {
+          'type' => 'Point',
+          'coordinates' => [10.0, 20.0, -1.0],
+        }
+        assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
+        assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory_z).eql?(object_))
+      end
+      
+      
+      def test_point_m
+        object_ = @geo_factory_m.point(10, 20, -1)
+        json_ = {
+          'type' => 'Point',
+          'coordinates' => [10.0, 20.0, -1.0],
+        }
+        assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
+        assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory_m).eql?(object_))
+      end
+      
+      
+      def test_point_zm
+        object_ = @geo_factory_zm.point(10, 20, -1, -2)
+        json_ = {
+          'type' => 'Point',
+          'coordinates' => [10.0, 20.0, -1.0, -2.0],
+        }
+        assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
+        assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory_zm).eql?(object_))
       end
       
       
@@ -68,7 +104,7 @@ module RGeo
           'coordinates' => [[10.0, 20.0], [12.0, 22.0], [-3.0, 24.0]],
         }
         assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-        assert(::RGeo::GeoJSON.decode(json_, @geo_factory).eql?(object_))
+        assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
       end
       
       
@@ -79,7 +115,7 @@ module RGeo
           'coordinates' => [[[10.0, 20.0], [12.0, 22.0], [-3.0, 24.0], [10.0, 20.0]]],
         }
         assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-        assert(::RGeo::GeoJSON.decode(json_, @geo_factory).eql?(object_))
+        assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
       end
       
       
@@ -90,7 +126,7 @@ module RGeo
           'coordinates' => [[[0.0, 0.0], [10.0, 0.0], [10.0, 10.0], [0.0, 10.0], [0.0, 0.0]], [[4.0, 4.0], [6.0, 5.0], [4.0, 6.0], [4.0, 4.0]]],
         }
         assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-        assert(::RGeo::GeoJSON.decode(json_, @geo_factory).eql?(object_))
+        assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
       end
       
       
@@ -101,7 +137,7 @@ module RGeo
           'coordinates' => [[10.0, 20.0], [12.0, 22.0], [-3.0, 24.0]],
         }
         assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-        assert(::RGeo::GeoJSON.decode(json_, @geo_factory).eql?(object_))
+        assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
       end
       
       
@@ -112,7 +148,7 @@ module RGeo
           'coordinates' => [[[10.0, 20.0], [12.0, 22.0], [-3.0, 24.0]], [[1.0, 2.0], [3.0, 4.0]]],
         }
         assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-        assert(::RGeo::GeoJSON.decode(json_, @geo_factory).eql?(object_))
+        assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
       end
       
       
@@ -123,7 +159,7 @@ module RGeo
           'coordinates' => [[[[0.0, 0.0], [10.0, 0.0], [10.0, 10.0], [0.0, 10.0], [0.0, 0.0]], [[4.0, 4.0], [6.0, 5.0], [4.0, 6.0], [4.0, 4.0]]], [[[-10.0, -10.0], [-15.0, -10.0], [-10.0, -15.0], [-10.0, -10.0]]]]
         }
         assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-        assert(::RGeo::GeoJSON.decode(json_, @geo_factory).eql?(object_))
+        assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
       end
       
       
@@ -152,7 +188,7 @@ module RGeo
           ],
         }
         assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-        assert(::RGeo::GeoJSON.decode(json_, @geo_factory).eql?(object_))
+        assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
       end
       
       
@@ -167,7 +203,20 @@ module RGeo
           'properties' => {},
         }
         assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-        assert(::RGeo::GeoJSON.decode(json_, @geo_factory).eql?(object_))
+        assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
+      end
+      
+      
+      def test_feature_nulls
+        json_ = {
+          'type' => 'Feature',
+          'geometry' => nil,
+          'properties' => nil,
+        }
+        obj_ = ::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory)
+        assert_not_nil(obj_)
+        assert_nil(obj_.geometry)
+        assert_equal({}, obj_.properties)
       end
       
       
@@ -183,7 +232,7 @@ module RGeo
           'properties' => {'prop1' => 'foo', 'prop2' => 'bar'},
         }
         assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-        assert(::RGeo::GeoJSON.decode(json_, @geo_factory).eql?(object_))
+        assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
       end
       
       
@@ -220,7 +269,7 @@ module RGeo
           ]
         }
         assert_equal(json_, ::RGeo::GeoJSON.encode(object_))
-        assert(::RGeo::GeoJSON.decode(json_, @geo_factory).eql?(object_))
+        assert(::RGeo::GeoJSON.decode(json_, :geo_factory => @geo_factory).eql?(object_))
       end
       
       

data/tests/wkrep/tc_wkb_generator.rb

@@ -0,0 +1,249 @@
+# -----------------------------------------------------------------------------
+# 
+# Tests for WKT generator
+# 
+# -----------------------------------------------------------------------------
+# 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 WKRep  # :nodoc:
+      
+      class TestWKBGenerator < ::Test::Unit::TestCase  # :nodoc:
+        
+        
+        def setup
+          @factory = ::RGeo::Cartesian.simple_factory(:srid => 1000)
+          @factoryz = ::RGeo::Cartesian.simple_factory(:srid => 1000, :support_z_coordinate => true)
+          @factorym = ::RGeo::Cartesian.simple_factory(:srid => 1000, :support_m_coordinate => true)
+          @factoryzm = ::RGeo::Cartesian.simple_factory(:srid => 1000, :support_z_coordinate => true, :support_m_coordinate => true)
+        end
+        
+        
+        def test_point_basic_xdr
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true)
+          obj_ = @factory.point(1, 2)
+          assert_equal('00000000013ff00000000000004000000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_point_basic_ndr
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :little_endian => true)
+          obj_ = @factory.point(1, 2)
+          assert_equal('0101000000000000000000f03f0000000000000040', generator_.generate(obj_))
+        end
+        
+        
+        def test_point_2d_ewkb
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :ewkb)
+          obj_ = @factory.point(1, 2)
+          assert_equal('00000000013ff00000000000004000000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_point_2d_wkb12
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :wkb12)
+          obj_ = @factory.point(1, 2)
+          assert_equal('00000000013ff00000000000004000000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_point_2d_ewkb_with_srid
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :ewkb, :emit_ewkb_srid => true)
+          obj_ = @factory.point(1, 2)
+          assert_equal('0020000001000003e83ff00000000000004000000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_point_with_ewkb_z
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :ewkb)
+          obj_ = @factoryz.point(1, 2, 3)
+          assert_equal('00800000013ff000000000000040000000000000004008000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_point_with_ewkb_m
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :ewkb)
+          obj_ = @factorym.point(1, 2, 3)
+          assert_equal('00400000013ff000000000000040000000000000004008000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_point_with_ewkb_zm
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :ewkb)
+          obj_ = @factoryzm.point(1, 2, 3, 4)
+          assert_equal('00c00000013ff0000000000000400000000000000040080000000000004010000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_point_with_wkb12_z
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :wkb12)
+          obj_ = @factoryz.point(1, 2, 3)
+          assert_equal('00000003e93ff000000000000040000000000000004008000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_point_with_wkb12_m
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :wkb12)
+          obj_ = @factorym.point(1, 2, 3)
+          assert_equal('00000007d13ff000000000000040000000000000004008000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_point_with_wkb12_zm
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :wkb12)
+          obj_ = @factoryzm.point(1, 2, 3, 4)
+          assert_equal('0000000bb93ff0000000000000400000000000000040080000000000004010000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_linestring_basic
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true)
+          obj_ = @factory.line_string([@factory.point(1, 2), @factory.point(3, 4), @factory.point(5, 6)])
+          assert_equal('0000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_linestring_with_ewkb_z
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :ewkb)
+          obj_ = @factoryz.line_string([@factoryz.point(1, 2, 3), @factoryz.point(4, 5, 6)])
+          assert_equal('0080000002000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_linestring_with_ewkb_z_and_srid
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :ewkb, :emit_ewkb_srid => true)
+          obj_ = @factoryz.line_string([@factoryz.point(1, 2, 3), @factoryz.point(4, 5, 6)])
+          assert_equal('00a0000002000003e8000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_linestring_with_wkb12_m
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :wkb12)
+          obj_ = @factorym.line_string([@factorym.point(1, 2, 3), @factorym.point(4, 5, 6)])
+          assert_equal('00000007d2000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_linestring_empty
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true)
+          obj_ = @factory.line_string([])
+          assert_equal('000000000200000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_polygon_basic
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true)
+          obj_ = @factory.polygon(@factory.linear_ring([@factory.point(1, 2), @factory.point(3, 4), @factory.point(6, 5), @factory.point(1, 2)]))
+          assert_equal('000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_polygon_empty
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true)
+          obj_ = @factory.polygon(@factory.linear_ring([]))
+          assert_equal('000000000300000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_multipoint_basic
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true)
+          obj_ = @factory.multi_point([@factory.point(1, 2), @factory.point(3, 4)])
+          assert_equal('00000000040000000200000000013ff00000000000004000000000000000000000000140080000000000004010000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_multipoint_with_ewkb_z
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true, :type_format => :ewkb)
+          obj_ = @factoryz.multi_point([@factoryz.point(1, 2, 5), @factoryz.point(3, 4, 6)])
+          assert_equal('00800000040000000200800000013ff0000000000000400000000000000040140000000000000080000001400800000000000040100000000000004018000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_multipoint_empty
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true)
+          obj_ = @factory.multi_point([])
+          assert_equal('000000000400000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_multilinestring_basic
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true)
+          obj_ = @factory.multi_line_string([@factory.line_string([@factory.point(1, 2), @factory.point(3, 4), @factory.point(5, 6)]), @factory.line_string([@factory.point(-1, -2), @factory.point(-3, -4)])])
+          assert_equal('0000000005000000020000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000000000000200000002bff0000000000000c000000000000000c008000000000000c010000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_multilinestring_empty
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true)
+          obj_ = @factory.multi_line_string([])
+          assert_equal('000000000500000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_multipolygon_basic
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true)
+          obj_ = @factory.multi_polygon([@factory.polygon(@factory.linear_ring([@factory.point(1, 2), @factory.point(3, 4), @factory.point(6, 5), @factory.point(1, 2)])), @factory.polygon(@factory.linear_ring([]))])
+          assert_equal('000000000600000002000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000000000000300000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_multipolygon_empty
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true)
+          obj_ = @factory.multi_polygon([])
+          assert_equal('000000000600000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_collection_basic
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true)
+          obj_ = @factory.collection([@factory.line_string([@factory.point(1, 2), @factory.point(3, 4), @factory.point(5, 6)]), @factory.point(-1, -2)])
+          assert_equal('0000000007000000020000000002000000033ff0000000000000400000000000000040080000000000004010000000000000401400000000000040180000000000000000000001bff0000000000000c000000000000000', generator_.generate(obj_))
+        end
+        
+        
+        def test_collection_empty
+          generator_ = ::RGeo::WKRep::WKBGenerator.new(:hex_format => true)
+          obj_ = @factory.collection([])
+          assert_equal('000000000700000000', generator_.generate(obj_))
+        end
+        
+        
+      end
+      
+    end
+  end
+end

data/tests/wkrep/tc_wkb_parser.rb

@@ -0,0 +1,353 @@
+# -----------------------------------------------------------------------------
+# 
+# Tests for WKT parser
+# 
+# -----------------------------------------------------------------------------
+# 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 WKRep  # :nodoc:
+      
+      class TestWKBParser < ::Test::Unit::TestCase  # :nodoc:
+        
+        
+        def test_point_2d_xdr
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse_hex('00000000013ff00000000000004000000000000000')
+          assert_equal(::RGeo::Features::Point, obj_.geometry_type)
+          assert_equal(1, obj_.x)
+          assert_equal(2, obj_.y)
+        end
+        
+        
+        def test_point_2d_ndr
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse_hex('0101000000000000000000f03f0000000000000040')
+          assert_equal(::RGeo::Features::Point, obj_.geometry_type)
+          assert_equal(1, obj_.x)
+          assert_equal(2, obj_.y)
+        end
+        
+        
+        def test_point_with_ewkb_z
+          factory_ = ::RGeo::Cartesian.preferred_factory(:support_z_coordinate => true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(:default_factory => factory_, :support_ewkb => true)
+          obj_ = parser_.parse_hex('00800000013ff000000000000040000000000000004008000000000000')
+          assert_equal(::RGeo::Features::Point, obj_.geometry_type)
+          assert_equal(3, obj_.z)
+          assert_nil(obj_.m)
+        end
+        
+        
+        def test_point_with_ewkb_m
+          factory_ = ::RGeo::Cartesian.preferred_factory(:support_m_coordinate => true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(:default_factory => factory_, :support_ewkb => true)
+          obj_ = parser_.parse_hex('00400000013ff000000000000040000000000000004008000000000000')
+          assert_equal(::RGeo::Features::Point, obj_.geometry_type)
+          assert_equal(3, obj_.m)
+          assert_nil(obj_.z)
+        end
+        
+        
+        def test_point_with_ewkb_zm
+          factory_ = ::RGeo::Cartesian.simple_factory(:support_z_coordinate => true, :support_m_coordinate => true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(:default_factory => factory_, :support_ewkb => true)
+          obj_ = parser_.parse_hex('00c00000013ff0000000000000400000000000000040080000000000004010000000000000')
+          assert_equal(::RGeo::Features::Point, obj_.geometry_type)
+          assert_equal(3, obj_.z)
+          assert_equal(4, obj_.m)
+        end
+        
+        
+        def test_point_with_wkb12_z
+          factory_ = ::RGeo::Cartesian.preferred_factory(:support_z_coordinate => true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(:default_factory => factory_, :support_wkb12 => true)
+          obj_ = parser_.parse_hex('00000003e93ff000000000000040000000000000004008000000000000')
+          assert_equal(::RGeo::Features::Point, obj_.geometry_type)
+          assert_equal(3, obj_.z)
+          assert_nil(obj_.m)
+        end
+        
+        
+        def test_point_with_wkb12_m
+          factory_ = ::RGeo::Cartesian.preferred_factory(:support_m_coordinate => true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(:default_factory => factory_, :support_wkb12 => true)
+          obj_ = parser_.parse_hex('00000007d13ff000000000000040000000000000004008000000000000')
+          assert_equal(::RGeo::Features::Point, obj_.geometry_type)
+          assert_equal(3, obj_.m)
+          assert_nil(obj_.z)
+        end
+        
+        
+        def test_point_with_wkb12_zm
+          factory_ = ::RGeo::Cartesian.simple_factory(:support_z_coordinate => true, :support_m_coordinate => true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(:default_factory => factory_, :support_wkb12 => true)
+          obj_ = parser_.parse_hex('0000000bb93ff0000000000000400000000000000040080000000000004010000000000000')
+          assert_equal(::RGeo::Features::Point, obj_.geometry_type)
+          assert_equal(3, obj_.z)
+          assert_equal(4, obj_.m)
+        end
+        
+        
+        def test_point_with_wkb12_z_without_wkb12_support
+          factory_ = ::RGeo::Cartesian.preferred_factory(:support_z_coordinate => true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(:default_factory => factory_)
+          assert_raise(::RGeo::Errors::ParseError) do
+            obj_ = parser_.parse_hex('00000003e93ff000000000000040000000000000004008000000000000')
+          end
+        end
+        
+        
+        def test_point_with_wkb12_z_without_enough_data
+          factory_ = ::RGeo::Cartesian.preferred_factory(:support_z_coordinate => true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(:default_factory => factory_, :support_wkb12 => true)
+          assert_raise(::RGeo::Errors::ParseError) do
+            obj_ = parser_.parse_hex('00000003e93ff00000000000004000000000000000')
+          end
+        end
+        
+        
+        def test_point_with_ewkb_z_and_srid
+          factory_ = ::RGeo::Cartesian.preferred_factory(:support_z_coordinate => true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(:default_factory => factory_, :support_ewkb => true)
+          parser_.set_factory_from_srid do |srid_|
+            ::RGeo::Cartesian.preferred_factory(:support_z_coordinate => true, :srid => srid_)
+          end
+          obj_ = parser_.parse_hex('00a0000001000003e83ff000000000000040000000000000004008000000000000')
+          assert_equal(::RGeo::Features::Point, obj_.geometry_type)
+          assert_equal(3, obj_.z)
+          assert_nil(obj_.m)
+          assert_equal(1000, obj_.srid)
+        end
+        
+        
+        def test_linestring_basic
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse_hex('0000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
+          assert_equal(::RGeo::Features::LineString, obj_.geometry_type)
+          assert_equal(3, obj_.num_points)
+          assert_equal(1, obj_.point_n(0).x)
+          assert_equal(6, obj_.point_n(2).y)
+        end
+        
+        
+        def test_linestring_with_ewkb_z
+          factory_ = ::RGeo::Cartesian.preferred_factory(:support_z_coordinate => true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(:default_factory => factory_, :support_ewkb => true)
+          obj_ = parser_.parse_hex('0080000002000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
+          assert_equal(::RGeo::Features::LineString, obj_.geometry_type)
+          assert_equal(2, obj_.num_points)
+          assert_equal(1, obj_.point_n(0).x)
+          assert_equal(6, obj_.point_n(1).z)
+        end
+        
+        
+        def test_linestring_with_ewkb_z_and_srid
+          factory_ = ::RGeo::Cartesian.preferred_factory(:support_z_coordinate => true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(:default_factory => factory_, :support_ewkb => true)
+          parser_.set_factory_from_srid do |srid_|
+            ::RGeo::Cartesian.preferred_factory(:support_z_coordinate => true, :srid => srid_)
+          end
+          obj_ = parser_.parse_hex('00a0000002000003e8000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
+          assert_equal(::RGeo::Features::LineString, obj_.geometry_type)
+          assert_equal(2, obj_.num_points)
+          assert_equal(1, obj_.point_n(0).x)
+          assert_equal(6, obj_.point_n(1).z)
+          assert_equal(1000, obj_.srid)
+        end
+        
+        
+        def test_linestring_with_wkb12_z
+          factory_ = ::RGeo::Cartesian.preferred_factory(:support_z_coordinate => true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(:default_factory => factory_, :support_wkb12 => true)
+          obj_ = parser_.parse_hex('00000003ea000000023ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000')
+          assert_equal(::RGeo::Features::LineString, obj_.geometry_type)
+          assert_equal(2, obj_.num_points)
+          assert_equal(1, obj_.point_n(0).x)
+          assert_equal(6, obj_.point_n(1).z)
+        end
+        
+        
+        def test_linestring_empty
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse_hex('000000000200000000')
+          assert_equal(::RGeo::Features::LineString, obj_.geometry_type)
+          assert_equal(0, obj_.num_points)
+        end
+        
+        
+        def test_polygon_basic
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse_hex('000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000')
+          assert_equal(::RGeo::Features::Polygon, obj_.geometry_type)
+          assert_equal(4, obj_.exterior_ring.num_points)
+          assert_equal(1, obj_.exterior_ring.point_n(0).x)
+          assert_equal(5, obj_.exterior_ring.point_n(2).y)
+        end
+        
+        
+        def test_polygon_empty
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse_hex('000000000300000000')
+          assert_equal(::RGeo::Features::Polygon, obj_.geometry_type)
+          assert_equal(0, obj_.exterior_ring.num_points)
+        end
+        
+        
+        def test_multipoint_basic
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse_hex('00000000040000000200000000013ff00000000000004000000000000000000000000140080000000000004010000000000000')
+          assert_equal(::RGeo::Features::MultiPoint, obj_.geometry_type)
+          assert_equal(2, obj_.num_geometries)
+          assert_equal(1, obj_[0].x)
+          assert_equal(4, obj_[1].y)
+        end
+        
+        
+        def test_multipoint_mixed_byte_order
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse_hex('0000000004000000020101000000000000000000f03f0000000000000040000000000140080000000000004010000000000000')
+          assert_equal(::RGeo::Features::MultiPoint, obj_.geometry_type)
+          assert_equal(2, obj_.num_geometries)
+          assert_equal(1, obj_[0].x)
+          assert_equal(4, obj_[1].y)
+        end
+        
+        
+        def test_multipoint_with_ewkb_z
+          factory_ = ::RGeo::Cartesian.preferred_factory(:support_z_coordinate => true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(:default_factory => factory_, :support_ewkb => true)
+          obj_ = parser_.parse_hex('00800000040000000200800000013ff0000000000000400000000000000040140000000000000080000001400800000000000040100000000000004018000000000000')
+          assert_equal(::RGeo::Features::MultiPoint, obj_.geometry_type)
+          assert_equal(2, obj_.num_geometries)
+          assert_equal(1, obj_[0].x)
+          assert_equal(5, obj_[0].z)
+          assert_equal(4, obj_[1].y)
+          assert_equal(6, obj_[1].z)
+          assert_nil(obj_[0].m)
+        end
+        
+        
+        def test_multipoint_ewkb_with_mixed_z
+          factory_ = ::RGeo::Cartesian.preferred_factory(:support_z_coordinate => true)
+          parser_ = ::RGeo::WKRep::WKBParser.new(:default_factory => factory_, :support_ewkb => true)
+          assert_raise(::RGeo::Errors::ParseError) do
+            obj_ = parser_.parse_hex('00800000040000000200800000013ff000000000000040000000000000004014000000000000000000000140080000000000004010000000000000')
+          end
+        end
+        
+        
+        def test_multipoint_empty
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse_hex('000000000400000000')
+          assert_equal(::RGeo::Features::MultiPoint, obj_.geometry_type)
+          assert_equal(0, obj_.num_geometries)
+        end
+        
+        
+        def test_multilinestring_basic
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse_hex('0000000005000000020000000002000000033ff000000000000040000000000000004008000000000000401000000000000040140000000000004018000000000000000000000200000002bff0000000000000c000000000000000c008000000000000c010000000000000')
+          assert_equal(::RGeo::Features::MultiLineString, obj_.geometry_type)
+          assert_equal(2, obj_.num_geometries)
+          assert_equal(1, obj_[0].point_n(0).x)
+          assert_equal(-4, obj_[1].point_n(1).y)
+        end
+        
+        
+        def test_multilinestring_wrong_element_type
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          assert_raise(::RGeo::Errors::ParseError) do
+            obj_ = parser_.parse_hex('0000000005000000020000000002000000033ff00000000000004000000000000000400800000000000040100000000000004014000000000000401800000000000000000000013ff00000000000004000000000000000')
+          end
+        end
+        
+        
+        def test_multilinestring_empty
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse_hex('000000000500000000')
+          assert_equal(::RGeo::Features::MultiLineString, obj_.geometry_type)
+          assert_equal(0, obj_.num_geometries)
+        end
+        
+        
+        def test_multipolygon_basic
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse_hex('000000000600000002000000000300000001000000043ff0000000000000400000000000000040080000000000004010000000000000401800000000000040140000000000003ff00000000000004000000000000000000000000300000000')
+          assert_equal(::RGeo::Features::MultiPolygon, obj_.geometry_type)
+          assert_equal(2, obj_.num_geometries)
+          assert_equal(4, obj_[0].exterior_ring.num_points)
+          assert_equal(1, obj_[0].exterior_ring.point_n(0).x)
+          assert_equal(5, obj_[0].exterior_ring.point_n(2).y)
+          assert_equal(0, obj_[1].exterior_ring.num_points)
+        end
+        
+        
+        def test_multipolygon_empty
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse_hex('000000000600000000')
+          assert_equal(::RGeo::Features::MultiPolygon, obj_.geometry_type)
+          assert_equal(0, obj_.num_geometries)
+        end
+        
+        
+        def test_collection_basic
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse_hex('0000000007000000020000000002000000033ff0000000000000400000000000000040080000000000004010000000000000401400000000000040180000000000000000000001bff0000000000000c000000000000000')
+          assert_equal(::RGeo::Features::GeometryCollection, obj_.geometry_type)
+          assert_equal(2, obj_.num_geometries)
+          assert_equal(::RGeo::Features::LineString, obj_[0].geometry_type)
+          assert_equal(1, obj_[0].point_n(0).x)
+          assert_equal(6, obj_[0].point_n(2).y)
+          assert_equal(::RGeo::Features::Point, obj_[1].geometry_type)
+          assert_equal(-1, obj_[1].x)
+        end
+        
+        
+        def test_collection_empty
+          parser_ = ::RGeo::WKRep::WKBParser.new
+          obj_ = parser_.parse_hex('000000000700000000')
+          assert_equal(::RGeo::Features::GeometryCollection, obj_.geometry_type)
+          assert_equal(0, obj_.num_geometries)
+        end
+        
+        
+      end
+      
+    end
+  end
+end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 0
   - 1
-  - 15
-  version: 0.1.15
+  - 16
+  version: 0.1.16
 platform: ruby
 authors: 
 - Daniel Azuma
@@ -14,24 +14,10 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-11-08 00:00:00 -08:00
+date: 2010-11-18 00:00:00 -08:00
 default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: json
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 1
-        - 4
-        - 6
-        version: 1.4.6
-  type: :runtime
-  version_requirements: *id001
+dependencies: []
+
 description: RGeo is a spatial data library for Ruby. It provides an implementation of the Open Geospatial Consortium's Simple Features Specification, used by most standard spatial/geographic data storage systems such as PostGIS. It also provides a suite of useful tools for writing location-based applications using Ruby-based frameworks such as Ruby On Rails.
 email: dazuma@gmail.com
 executables: []
@@ -146,6 +132,8 @@ files:
 - tests/simple_spherical/tc_polygon.rb
 - tests/tc_geojson.rb
 - tests/tc_oneoff.rb
+- tests/wkrep/tc_wkb_generator.rb
+- tests/wkrep/tc_wkb_parser.rb
 - tests/wkrep/tc_wkt_generator.rb
 - tests/wkrep/tc_wkt_parser.rb
 - ext/geos_c_impl/extconf.rb
@@ -241,5 +229,7 @@ test_files:
 - tests/simple_spherical/tc_polygon.rb
 - tests/tc_geojson.rb
 - tests/tc_oneoff.rb
+- tests/wkrep/tc_wkb_generator.rb
+- tests/wkrep/tc_wkb_parser.rb
 - tests/wkrep/tc_wkt_generator.rb
 - tests/wkrep/tc_wkt_parser.rb