rgeo 0.2.8 → 0.2.9

data/lib/rgeo/geographic/proj4_projector.rb

@@ -82,7 +82,14 @@ module RGeo
         
         
         def create_from_proj4(geography_factory_, proj4_, opts_={})
-          projection_factory_ = Cartesian.preferred_factory(:proj4 => proj4_, :coord_sys => opts_[:coord_sys], :srid => opts_[:srid], :buffer_resolution => opts_[:buffer_resolution], :lenient_multi_polygon_assertions => opts_[:lenient_multi_polygon_assertions], :has_z_coordinate => opts_[:has_z_coordinate], :has_m_coordinate => opts_[:has_m_coordinate])
+          projection_factory_ = Cartesian.preferred_factory(:proj4 => proj4_,
+            :coord_sys => opts_[:coord_sys], :srid => opts_[:srid],
+            :buffer_resolution => opts_[:buffer_resolution],
+            :lenient_multi_polygon_assertions => opts_[:lenient_multi_polygon_assertions],
+            :has_z_coordinate => opts_[:has_z_coordinate],
+            :has_m_coordinate => opts_[:has_m_coordinate],
+            :wkt_parser => opts_[:wkt_parser], :wkt_generator => opts_[:wkt_generator],
+            :wkb_parser => opts_[:wkb_parser], :wkb_generator => opts_[:wkb_generator])
           new(geography_factory_, projection_factory_)
         end
         

data/lib/rgeo/geos.rb

@@ -51,7 +51,7 @@ module RGeo
   # therefore not documented.
   # 
   # To use the Geos implementation, first obtain a factory using the
-  # ::RGeo::Geos::factory method. You may then call any of the standard
+  # ::RGeo::Geos.factory method. You may then call any of the standard
   # factory methods on the resulting object.
   
   module Geos

data/lib/rgeo/geos/factory.rb

@@ -53,10 +53,13 @@ module RGeo
         # Create a new factory. Returns nil if the GEOS implementation is
         # not supported.
         # 
-        # See ::RGeo::Geos::factory for a list of supported options.
+        # See ::RGeo::Geos.factory for a list of supported options.
         
         def create(opts_={})
+          # Make sure GEOS is available
           return nil unless respond_to?(:_create)
+          
+          # Get flags to pass to the C extension
           flags_ = 0
           flags_ |= 1 if opts_[:lenient_multi_polygon_assertions]
           flags_ |= 2 if opts_[:has_z_coordinate]
@@ -64,8 +67,32 @@ module RGeo
           if flags_ & 6 == 6
             raise Error::UnsupportedOperation, "GEOS cannot support both Z and M coordinates at the same time."
           end
+          
+          # Buffer resolution
           buffer_resolution_ = opts_[:buffer_resolution].to_i
           buffer_resolution_ = 1 if buffer_resolution_ < 1
+          
+          # Interpret the generator options
+          wkt_generator_ = opts_[:wkt_generator]
+          case wkt_generator_
+          when :geos
+            wkt_generator_ = nil
+          when ::Hash
+            wkt_generator_ = WKRep::WKTGenerator.new(wkt_generator_)
+          else
+            wkt_generator_ = WKRep::WKTGenerator.new(:convert_case => :upper)
+          end
+          wkb_generator_ = opts_[:wkb_generator]
+          case wkb_generator_
+          when :geos
+            wkb_generator_ = nil
+          when ::Hash
+            wkb_generator_ = WKRep::WKBGenerator.new(wkb_generator_)
+          else
+            wkb_generator_ = WKRep::WKBGenerator.new
+          end
+          
+          # Coordinate system (srid, proj4, and coord_sys)
           srid_ = opts_[:srid]
           proj4_ = opts_[:proj4]
           if CoordSys::Proj4.supported?
@@ -87,9 +114,39 @@ module RGeo
             end
           end
           srid_ ||= coord_sys_.authority_code if coord_sys_
-          result_ = _create(flags_, srid_.to_i, buffer_resolution_)
+          
+          # Create the factory and set instance variables
+          result_ = _create(flags_, srid_.to_i, buffer_resolution_, wkt_generator_, wkb_generator_)
+          
+          # Interpret parser options
+          wkt_parser_ = opts_[:wkt_parser]
+          case wkt_parser_
+          when :geos
+            wkt_parser_ = nil
+          when ::Hash
+            wkt_parser_ = WKRep::WKTParser.new(result_, wkt_parser_)
+          else
+            wkt_parser_ = WKRep::WKTParser.new(result_)
+          end
+          wkb_parser_ = opts_[:wkb_parser]
+          case wkb_parser_
+          when :geos
+            wkb_parser_ = nil
+          when ::Hash
+            wkb_parser_ = WKRep::WKBParser.new(result_, wkb_parser_)
+          else
+            wkb_parser_ = WKRep::WKBParser.new(result_)
+          end
+          
+          # Set instance variables
           result_.instance_variable_set(:@proj4, proj4_)
           result_.instance_variable_set(:@coord_sys, coord_sys_)
+          result_.instance_variable_set(:@wkt_parser, wkt_parser_)
+          result_.instance_variable_set(:@wkb_parser, wkb_parser_)
+          result_.instance_variable_set(:@wkt_generator, wkt_generator_)
+          result_.instance_variable_set(:@wkb_generator, wkb_generator_)
+          
+          # Return the result
           result_
         end
         alias_method :new, :create
@@ -152,14 +209,22 @@ module RGeo
       # See ::RGeo::Feature::Factory#parse_wkt
       
       def parse_wkt(str_)
-        _parse_wkt_impl(str_)
+        if @wkt_parser
+          @wkt_parser.parse(str_)
+        else
+          _parse_wkt_impl(str_)
+        end
       end
       
       
       # See ::RGeo::Feature::Factory#parse_wkb
       
       def parse_wkb(str_)
-        _parse_wkb_impl(str_)
+        if @wkb_parser
+          @wkb_parser.parse(str_)
+        else
+          _parse_wkb_impl(str_)
+        end
       end
       
       

data/lib/rgeo/geos/impl_additions.rb

@@ -63,7 +63,7 @@ module RGeo
           Feature::MultiPoint => MultiPointImpl,
           Feature::MultiLineString => MultiLineStringImpl,
           Feature::MultiPolygon => MultiPolygonImpl,
-        }
+        }.freeze
       end
       # :startdoc:
       

data/lib/rgeo/geos/interface.rb

@@ -105,6 +105,37 @@ module RGeo
       #   Support <tt>z_coordinate</tt>. Default is false.
       # [<tt>:has_m_coordinate</tt>]
       #   Support <tt>m_coordinate</tt>. Default is false.
+      # [<tt>:wkt_parser</tt>]
+      #   Configure the parser for WKT. You may either pass a hash of
+      #   configuration parameters for WKRep::WKTParser.new, or the
+      #   special value <tt>:geos</tt>, indicating to use the native
+      #   GEOS parser. Default is the empty hash, indicating the default
+      #   configuration for WKRep::WKTParser.
+      #   Note that the special <tt>:geos</tt> value is not supported for
+      #   ZM factories, since GEOS currently can't handle ZM natively.
+      # [<tt>:wkb_parser</tt>]
+      #   Configure the parser for WKB. You may either pass a hash of
+      #   configuration parameters for WKRep::WKBParser.new, or the
+      #   special value <tt>:geos</tt>, indicating to use the native
+      #   GEOS parser. Default is the empty hash, indicating the default
+      #   configuration for WKRep::WKBParser.
+      #   Note that the special <tt>:geos</tt> value is not supported for
+      #   ZM factories, since GEOS currently can't handle ZM natively.
+      # [<tt>:wkt_generator</tt>]
+      #   Configure the generator for WKT. You may either pass a hash of
+      #   configuration parameters for WKRep::WKTGenerator.new, or the
+      #   special value <tt>:geos</tt>, indicating to use the native
+      #   GEOS generator. Default is <tt>{:convert_case => :upper}</tt>.
+      #   Note that the special <tt>:geos</tt> value is not supported for
+      #   ZM factories, since GEOS currently can't handle ZM natively.
+      # [<tt>:wkb_generator</tt>]
+      #   Configure the generator for WKB. You may either pass a hash of
+      #   configuration parameters for WKRep::WKBGenerator.new, or the
+      #   special value <tt>:geos</tt>, indicating to use the native
+      #   GEOS generator. Default is the empty hash, indicating the
+      #   default configuration for WKRep::WKBGenerator.
+      #   Note that the special <tt>:geos</tt> value is not supported for
+      #   ZM factories, since GEOS currently can't handle ZM natively.
       
       def factory(opts_={})
         if supported?

data/lib/rgeo/geos/zm_factory.rb

@@ -76,10 +76,41 @@ module RGeo
         config_ = {
           :lenient_multi_polygon_assertions => opts_[:lenient_multi_polygon_assertions],
           :buffer_resolution => opts_[:buffer_resolution],
+          :wkt_generator => opts_[:wkt_generator], :wkt_parser => opts_[:wkt_parser],
+          :wkb_generator => opts_[:wkb_generator], :wkb_parser => opts_[:wkb_parser],
           :srid => srid_.to_i, :proj4 => proj4_, :coord_sys => coord_sys_,
         }
         @zfactory = Factory.create(config_.merge(:has_z_coordinate => true))
         @mfactory = Factory.create(config_.merge(:has_m_coordinate => true))
+        
+        wkt_generator_ = opts_[:wkt_generator]
+        case wkt_generator_
+        when ::Hash
+          @wkt_generator = WKRep::WKTGenerator.new(wkt_generator_)
+        else
+          @wkt_generator = WKRep::WKTGenerator.new(:convert_case => :upper)
+        end
+        wkb_generator_ = opts_[:wkb_generator]
+        case wkb_generator_
+        when ::Hash
+          @wkb_generator = WKRep::WKBGenerator.new(wkb_generator_)
+        else
+          @wkb_generator = WKRep::WKBGenerator.new
+        end
+        wkt_parser_ = opts_[:wkt_parser]
+        case wkt_parser_
+        when ::Hash
+          @wkt_parser = WKRep::WKTParser.new(self, wkt_parser_)
+        else
+          @wkt_parser = WKRep::WKTParser.new(self)
+        end
+        wkb_parser_ = opts_[:wkb_parser]
+        case wkb_parser_
+        when ::Hash
+          @wkb_parser = WKRep::WKBParser.new(self, wkb_parser_)
+        else
+          @wkb_parser = WKRep::WKBParser.new(self)
+        end
       end
       
       
@@ -142,14 +173,14 @@ module RGeo
       # See ::RGeo::Feature::Factory#parse_wkt
       
       def parse_wkt(str_)
-        WKRep::WKTParser.new(self).parse(str_)
+        @wkt_parser.parse(str_)
       end
       
       
       # See ::RGeo::Feature::Factory#parse_wkb
       
       def parse_wkb(str_)
-        WKRep::WKBParser.new(self).parse(str_)
+        @wkb_parser.parse(str_)
       end
       
       

data/lib/rgeo/geos/zm_impl.rb

@@ -101,12 +101,12 @@ module RGeo
       
       
       def as_text
-        WKRep::WKTGenerator.new.generate(self)
+        @factory.instance_variable_get(:@wkt_generator).generate(self)
       end
       
       
       def as_binary
-        WKRep::WKBGenerator.new.generate(self)
+        @factory.instance_variable_get(:@wkb_generator).generate(self)
       end
       
       
@@ -415,7 +415,7 @@ module RGeo
         Feature::MultiPoint => ZMGeometryCollectionImpl,
         Feature::MultiLineString => ZMMultiLineStringImpl,
         Feature::MultiPolygon => ZMMultiPolygonImpl,
-      }
+      }.freeze
       
       
       def self.create(factory_, zgeometry_, mgeometry_)

data/lib/rgeo/impl_helper/basic_geometry_methods.rb

@@ -68,12 +68,12 @@ module RGeo
       
       
       def as_text
-        WKRep::WKTGenerator.new.generate(self)
+        @factory.instance_variable_get(:@wkt_generator).generate(self)
       end
       
       
       def as_binary
-        WKRep::WKBGenerator.new.generate(self)
+        @factory.instance_variable_get(:@wkb_generator).generate(self)
       end
       
       

data/lib/rgeo/wkrep/wkb_generator.rb

@@ -85,7 +85,7 @@ module RGeo
         Feature::MultiLineString => 5,
         Feature::MultiPolygon => 6,
         Feature::GeometryCollection => 7,
-      }
+      }.freeze
       # :startdoc:
       
       
@@ -105,46 +105,23 @@ module RGeo
         @type_format
       end
       
-      # Sets the format for type codes. See WKBGenerator for details.
-      def type_format=(value_)
-        @type_format = value_
-      end
-      
       # Returns whether SRID is embedded. See WKBGenerator for details.
       def emit_ewkb_srid?
         @emit_ewkb_srid
       end
       
-      # Sets whether SRID is embedded. Available only when the type_format
-      # is <tt>:ewkb</tt>. See WKBGenerator for details.
-      def emit_ewkb_srid=(value_)
-        @emit_ewkb_srid = @type_format == :ewkb && value_
-      end
-      
       # Returns whether output is converted to hex.
       # See WKBGenerator for details.
       def hex_format?
         @hex_format
       end
       
-      # Sets whether output is converted to hex.
-      # See WKBGenerator for details.
-      def hex_format=(value_)
-        @hex_format = value_ ? true : false
-      end
-      
       # Returns whether output is little-endian (NDR).
       # See WKBGenerator for details.
       def little_endian?
         @little_endian
       end
       
-      # Sets whether output is little-endian (NDR).
-      # See WKBGenerator for details.
-      def little_endian=(value_)
-        @little_endian = value_ ? true : false
-      end
-      
       
       # Generate and return the WKB format for the given geometry object,
       # according to the current settings.

data/lib/rgeo/wkrep/wkb_parser.rb

@@ -81,7 +81,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_ewkb = opts_[:support_ewkb] ? true : false
         @support_wkb12 = opts_[:support_wkb12] ? true : false
         @ignore_extra_bytes = opts_[:ignore_extra_bytes] ? true : false
@@ -100,70 +109,41 @@ module RGeo
         @exact_factory
       end
       
-      # Sets the factory_generator. See WKBParser 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 WKBParser for details.
-      def to_generate_factory(&block_)
-        @factory_generator = 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*'))
+      # Returns true if this parser can auto-detect hex.
+      # See WKBParser for details.
+      def auto_detect_hex?
+        @auto_detect_hex
       end
       
       
-      # Parse the given binary data, and return a geometry object.
+      # Parse the given binary data or hexadecimal string, and return a
+      # geometry object.
+      # 
+      # The #parse_hex method is a synonym, present for historical
+      # reasons but deprecated. Use #parse instead.
       
       def parse(data_)
+        if data_[0,1] =~ /[0-9a-fA-F]/
+          data_ = [data_].pack('H*')
+        end
         @cur_has_z = nil
         @cur_has_m = nil
         @cur_srid = nil
@@ -183,10 +163,19 @@ module RGeo
         end
         obj_
       end
+      alias_method :parse_hex, :parse
       
       
       def _parse_object(contained_)  # :nodoc:
-        little_endian_ = _get_byte == 1
+        endian_value_ = _get_byte
+        case endian_value_
+        when 0
+          little_endian_ = false
+        when 1
+          little_endian_ = true
+        else
+          raise Error::ParseError, "Bad endian byte value: #{endian_value_}"
+        end
         type_code_ = _get_integer(little_endian_)
         has_z_ = false
         has_m_ = false