rgeo 1.1.2 → 2.2.0

data/lib/rgeo/impl_helper/math.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Math constants and tools

data/lib/rgeo/impl_helper/utils.rb

@@ -1,28 +1,22 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
-# Math constants and tools
+# Utility module
 #
 # -----------------------------------------------------------------------------
 
 module RGeo
   module ImplHelper # :nodoc:
     module Utils # :nodoc:
-      class << self
-        def stringize_hash(hash_)
-          nhash_ = {}
-          hash_.each do |k_, v_|
-            nhash_[k_.is_a?(::Symbol) ? k_.to_s : k_] = v_.is_a?(::Symbol) ? v_.to_s : v_
-          end
-          nhash_
-        end
+      private
 
-        def symbolize_hash(hash_)
-          nhash_ = {}
-          hash_.each do |k_, v_|
-            nhash_[k_.is_a?(::String) ? k_.to_sym : k_] = v_.is_a?(::String) ? v_.to_sym : v_
-          end
-          nhash_
+      def symbolize_hash(hash)
+        nhash = {}
+        hash.each do |k, v|
+          nhash[k.to_sym] = v.is_a?(String) ? v.to_sym : v
         end
+        nhash
       end
     end
   end

data/lib/rgeo/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module RGeo
-  VERSION = "1.1.2".freeze
+  VERSION = "2.2.0"
 end

data/lib/rgeo/wkrep.rb

@@ -1,37 +1,27 @@
-# -----------------------------------------------------------------------------
+# frozen_string_literal: true
+
+# The WKRep module contains implementations of the OpenGIS well-known
+# representations: the WKT (well-known text representation) and the
+# WKB (well-known binary representation), as defined in the Simple
+# Features Specification, version 1.1. Facilities are provided to
+# serialize any geometry into one of these formats, and to parse a
+# serialized string back into a geometry. Support is also provided for
+# the common extensions to these formats-- notably, the EWKT and EWKB
+# formats used by PostGIS.
 #
-# Well-known representation for RGeo
+# To serialize a geometry into WKT (well-known text) format, use
+# the WKRep::WKTGenerator class.
 #
-# -----------------------------------------------------------------------------
-
-module RGeo
-  # This module contains implementations of the OpenGIS well-known
-  # representations: the WKT (well-known text representation) and the
-  # WKB (well-known binary representation), as defined in the Simple
-  # Features Specification, version 1.1. Facilities are provided to
-  # serialize any geometry into one of these formats, and to parse a
-  # serialized string back into a geometry. Support is also provided for
-  # the common extensions to these formats-- notably, the EWKT and EWKB
-  # formats used by PostGIS.
-  #
-  # To serialize a geometry into WKT (well-known text) format, use
-  # the WKRep::WKTGenerator class.
-  #
-  # To serialize a geometry into WKB (well-known binary) format, use
-  # the WKRep::WKBGenerator class.
-  #
-  # To parse a string in WKT (well-known text) format back into a
-  # geometry object, use the WKRep::WKTParser class.
-  #
-  # To parse a byte string in WKB (well-known binary) format back into a
-  # geometry object, use the WKRep::WKBParser class.
-
-  module WKRep
-  end
-end
+# To serialize a geometry into WKB (well-known binary) format, use
+# the WKRep::WKBGenerator class.
+#
+# To parse a string in WKT (well-known text) format back into a
+# geometry object, use the WKRep::WKTParser class.
+#
+# To parse a byte string in WKB (well-known binary) format back into a
+# geometry object, use the WKRep::WKBParser class.
 
-# Implementation files
-require "rgeo/wkrep/wkt_parser"
-require "rgeo/wkrep/wkt_generator"
-require "rgeo/wkrep/wkb_parser"
-require "rgeo/wkrep/wkb_generator"
+require_relative "wkrep/wkt_parser"
+require_relative "wkrep/wkt_generator"
+require_relative "wkrep/wkb_parser"
+require_relative "wkrep/wkb_generator"

data/lib/rgeo/wkrep/wkb_generator.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Well-known binary generator for RGeo
@@ -56,12 +58,11 @@ module RGeo
       # Create and configure a WKB generator. See the WKBGenerator
       # documentation for the options that can be passed.
 
-      def initialize(opts_ = {})
-        @type_format = opts_[:type_format] || :wkb11
-        @emit_ewkb_srid = @type_format == :ewkb ?
-          (opts_[:emit_ewkb_srid] ? true : false) : nil
-        @hex_format = opts_[:hex_format] ? true : false
-        @little_endian = opts_[:little_endian] ? true : false
+      def initialize(opts = {})
+        @type_format = opts[:type_format] || :wkb11
+        @emit_ewkb_srid = @type_format == :ewkb && opts[:emit_ewkb_srid]
+        @hex_format = opts[:hex_format] ? true : false
+        @little_endian = opts[:little_endian] ? true : false
       end
 
       # Returns the format for type codes. See WKBGenerator for details.
@@ -84,7 +85,7 @@ module RGeo
         @little_endian
       end
 
-      def _properties # :nodoc:
+      def properties
         {
           "type_format" => @type_format.to_s,
           "emit_ewkb_srid" => @emit_ewkb_srid,
@@ -96,105 +97,107 @@ module RGeo
       # Generate and return the WKB format for the given geometry object,
       # according to the current settings.
 
-      def generate(obj_)
-        factory_ = obj_.factory
+      def generate(obj)
+        factory = obj.factory
         if @type_format == :ewkb || @type_format == :wkb12
-          @cur_has_z = factory_.property(:has_z_coordinate)
-          @cur_has_m = factory_.property(:has_m_coordinate)
+          @cur_has_z = factory.property(:has_z_coordinate)
+          @cur_has_m = factory.property(:has_m_coordinate)
         else
           @cur_has_z = nil
           @cur_has_m = nil
         end
         @cur_dims = 2 + (@cur_has_z ? 1 : 0) + (@cur_has_m ? 1 : 0)
-        _start_emitter
-        _generate_feature(obj_, true)
-        _finish_emitter
+        start_emitter
+        generate_feature(obj, true)
+        finish_emitter
       end
 
-      def _generate_feature(obj_, toplevel_ = false) # :nodoc:
-        _emit_byte(@little_endian ? 1 : 0)
-        type_ = obj_.geometry_type
-        type_code_ = TYPE_CODES[type_]
-        unless type_code_
-          raise Error::ParseError, "Unrecognized Geometry Type: #{type_}"
-        end
-        emit_srid_ = false
-        if @type_format == :ewkb
-          type_code_ |= 0x80000000 if @cur_has_z
-          type_code_ |= 0x40000000 if @cur_has_m
-          if @emit_ewkb_srid && toplevel_
-            type_code_ |= 0x20000000
-            emit_srid_ = true
-          end
-        elsif @type_format == :wkb12
-          type_code_ += 1000 if @cur_has_z
-          type_code_ += 2000 if @cur_has_m
-        end
-        _emit_integer(type_code_)
-        _emit_integer(obj_.srid) if emit_srid_
-        if type_ == Feature::Point
-          _emit_doubles(_point_coords(obj_))
-        elsif type_.subtype_of?(Feature::LineString)
-          _emit_line_string_coords(obj_)
-        elsif type_ == Feature::Polygon
-          exterior_ring_ = obj_.exterior_ring
-          if exterior_ring_.is_empty?
-            _emit_integer(0)
-          else
-            _emit_integer(1 + obj_.num_interior_rings)
-            _emit_line_string_coords(exterior_ring_)
-            obj_.interior_rings.each { |r_| _emit_line_string_coords(r_) }
-          end
-        elsif type_ == Feature::GeometryCollection
-          _emit_integer(obj_.num_geometries)
-          obj_.each { |g_| _generate_feature(g_) }
-        elsif type_ == Feature::MultiPoint
-          _emit_integer(obj_.num_geometries)
-          obj_.each { |g_| _generate_feature(g_) }
-        elsif type_ == Feature::MultiLineString
-          _emit_integer(obj_.num_geometries)
-          obj_.each { |g_| _generate_feature(g_) }
-        elsif type_ == Feature::MultiPolygon
-          _emit_integer(obj_.num_geometries)
-          obj_.each { |g_| _generate_feature(g_) }
-        end
-      end
+      private
 
-      def _point_coords(obj_, array_ = []) # :nodoc:
-        array_ << obj_.x
-        array_ << obj_.y
-        array_ << obj_.z if @cur_has_z
-        array_ << obj_.m if @cur_has_m
-        array_
+      def emit_byte(value)
+        @cur_array << [value].pack("C")
       end
 
-      def _emit_line_string_coords(obj_) # :nodoc:
-        array_ = []
-        obj_.points.each { |p_| _point_coords(p_, array_) }
-        _emit_integer(obj_.num_points)
-        _emit_doubles(array_)
+      def emit_integer(value)
+        @cur_array << [value].pack(@little_endian ? "V" : "N")
       end
 
-      def _start_emitter # :nodoc:
-        @cur_array = []
+      def emit_doubles(array)
+        @cur_array << array.pack(@little_endian ? "E*" : "G*")
       end
 
-      def _emit_byte(value_) # :nodoc:
-        @cur_array << [value_].pack("C")
+      def emit_line_string_coords(obj)
+        array = []
+        obj.points.each { |p| point_coords(p, array) }
+        emit_integer(obj.num_points)
+        emit_doubles(array)
       end
 
-      def _emit_integer(value_)  # :nodoc:
-        @cur_array << [value_].pack(@little_endian ? "V" : "N")
+      def point_coords(obj, array = [])
+        array << obj.x
+        array << obj.y
+        array << obj.z if @cur_has_z
+        array << obj.m if @cur_has_m
+        array
       end
 
-      def _emit_doubles(array_)  # :nodoc:
-        @cur_array << array_.pack(@little_endian ? "E*" : "G*")
+      def start_emitter
+        @cur_array = []
       end
 
-      def _finish_emitter # :nodoc:
-        str_ = @cur_array.join
+      def finish_emitter
+        str = @cur_array.join
         @cur_array = nil
-        @hex_format ? str_.unpack("H*")[0] : str_
+        @hex_format ? str.unpack("H*")[0] : str
+      end
+
+      def generate_feature(obj, toplevel = false)
+        emit_byte(@little_endian ? 1 : 0)
+        type = obj.geometry_type
+        type_code = TYPE_CODES[type]
+        unless type_code
+          raise Error::ParseError, "Unrecognized Geometry Type: #{type}"
+        end
+        emit_srid = false
+        if @type_format == :ewkb
+          type_code |= 0x80000000 if @cur_has_z
+          type_code |= 0x40000000 if @cur_has_m
+          if @emit_ewkb_srid && toplevel
+            type_code |= 0x20000000
+            emit_srid = true
+          end
+        elsif @type_format == :wkb12
+          type_code += 1000 if @cur_has_z
+          type_code += 2000 if @cur_has_m
+        end
+        emit_integer(type_code)
+        emit_integer(obj.srid) if emit_srid
+        if type == Feature::Point
+          emit_doubles(point_coords(obj))
+        elsif type.subtype_of?(Feature::LineString)
+          emit_line_string_coords(obj)
+        elsif type == Feature::Polygon
+          exterior_ring = obj.exterior_ring
+          if exterior_ring.is_empty?
+            emit_integer(0)
+          else
+            emit_integer(1 + obj.num_interior_rings)
+            emit_line_string_coords(exterior_ring)
+            obj.interior_rings.each { |r| emit_line_string_coords(r) }
+          end
+        elsif type == Feature::GeometryCollection
+          emit_integer(obj.num_geometries)
+          obj.each { |g| generate_feature(g) }
+        elsif type == Feature::MultiPoint
+          emit_integer(obj.num_geometries)
+          obj.each { |g| generate_feature(g) }
+        elsif type == Feature::MultiLineString
+          emit_integer(obj.num_geometries)
+          obj.each { |g| generate_feature(g) }
+        elsif type == Feature::MultiPolygon
+          emit_integer(obj.num_geometries)
+          obj.each { |g| generate_feature(g) }
+        end
       end
     end
   end

data/lib/rgeo/wkrep/wkb_parser.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # -----------------------------------------------------------------------------
 #
 # Well-known binary parser for RGeo
@@ -45,21 +47,21 @@ module RGeo
       # Create and configure a WKB parser. See the WKBParser
       # documentation for the options that can be passed.
 
-      def initialize(factory_generator_ = nil, opts_ = {})
-        if factory_generator_.is_a?(Feature::Factory::Instance)
-          @factory_generator = Feature::FactoryGenerator.single(factory_generator_)
-          @exact_factory = factory_generator_
-        elsif factory_generator_.respond_to?(:call)
-          @factory_generator = factory_generator_
+      def initialize(factory_generator = nil, opts = {})
+        if factory_generator.is_a?(Feature::Factory::Instance)
+          @factory_generator = Feature::FactoryGenerator.single(factory_generator)
+          @exact_factory = factory_generator
+        elsif factory_generator.respond_to?(:call)
+          @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
-        @default_srid = opts_[:default_srid]
+        @support_ewkb = opts[:support_ewkb] ? true : false
+        @support_wkb12 = opts[:support_wkb12] ? true : false
+        @ignore_extra_bytes = opts[:ignore_extra_bytes] ? true : false
+        @default_srid = opts[:default_srid]
       end
 
       # Returns the factory generator. See WKBParser for details.
@@ -87,7 +89,7 @@ module RGeo
         @ignore_extra_bytes
       end
 
-      def _properties # :nodoc:
+      def properties
         {
           "support_ewkb" => @support_ewkb,
           "support_wkb12" => @support_wkb12,
@@ -102,73 +104,75 @@ module RGeo
       # The #parse_hex method is a synonym, present for historical
       # reasons but deprecated. Use #parse instead.
 
-      def parse(data_)
-        data_ = [data_].pack("H*") if data_[0, 1] =~ /[0-9a-fA-F]/
+      def parse(data)
+        data = [data].pack("H*") if data[0, 1] =~ /[0-9a-fA-F]/
         @cur_has_z = nil
         @cur_has_m = nil
         @cur_srid = nil
         @cur_dims = 2
         @cur_factory = nil
         begin
-          _start_scanner(data_)
-          obj_ = _parse_object(false)
+          start_scanner(data)
+          obj = parse_object(false)
           unless @ignore_extra_bytes
-            bytes_ = _bytes_remaining
-            if bytes_ > 0
-              raise Error::ParseError, "Found #{bytes_} extra bytes at the end of the stream."
+            bytes = bytes_remaining
+            if bytes > 0
+              raise Error::ParseError, "Found #{bytes} extra bytes at the end of the stream."
             end
           end
         ensure
-          _clean_scanner
+          @data = nil
         end
-        obj_
+        obj
       end
       alias parse_hex parse
 
-      def _parse_object(contained_) # :nodoc:
-        endian_value_ = _get_byte
-        case endian_value_
+      private
+
+      def parse_object(contained)
+        endian_value = get_byte
+        case endian_value
         when 0
-          little_endian_ = false
+          little_endian = false
         when 1
-          little_endian_ = true
+          little_endian = true
         else
-          raise Error::ParseError, "Bad endian byte value: #{endian_value_}"
+          raise Error::ParseError, "Bad endian byte value: #{endian_value}"
         end
-        type_code_ = _get_integer(little_endian_)
-        has_z_ = false
-        has_m_ = false
-        srid_ = contained_ ? nil : @default_srid
+        type_code = get_integer(little_endian)
+        has_z = false
+        has_m = false
+        srid = contained ? nil : @default_srid
         if @support_ewkb
-          has_z_ ||= type_code_ & 0x80000000 != 0
-          has_m_ ||= type_code_ & 0x40000000 != 0
-          srid_ = _get_integer(little_endian_) if type_code_ & 0x20000000 != 0
-          type_code_ &= 0x0fffffff
+          has_z ||= type_code & 0x80000000 != 0
+          has_m ||= type_code & 0x40000000 != 0
+          srid = get_integer(little_endian) if type_code & 0x20000000 != 0
+          type_code &= 0x0fffffff
         end
         if @support_wkb12
-          has_z_ ||= (type_code_ / 1000) & 1 != 0
-          has_m_ ||= (type_code_ / 1000) & 2 != 0
-          type_code_ %= 1000
+          has_z ||= (type_code / 1000) & 1 != 0
+          has_m ||= (type_code / 1000) & 2 != 0
+          type_code %= 1000
         end
-        if contained_
-          if contained_ != true && contained_ != type_code_
-            raise Error::ParseError, "Enclosed type=#{type_code_} is different from container constraint #{contained_}"
+        if contained
+          if contained != true && contained != type_code
+            raise Error::ParseError, "Enclosed type=#{type_code} is different from container constraint #{contained}"
           end
-          if has_z_ != @cur_has_z
-            raise Error::ParseError, "Enclosed hasZ=#{has_z_} is different from toplevel hasZ=#{@cur_has_z}"
+          if has_z != @cur_has_z
+            raise Error::ParseError, "Enclosed hasZ=#{has_z} is different from toplevel hasZ=#{@cur_has_z}"
           end
-          if has_m_ != @cur_has_m
-            raise Error::ParseError, "Enclosed hasM=#{has_m_} is different from toplevel hasM=#{@cur_has_m}"
+          if has_m != @cur_has_m
+            raise Error::ParseError, "Enclosed hasM=#{has_m} is different from toplevel hasM=#{@cur_has_m}"
           end
-          if srid_ && srid_ != @cur_srid
-            raise Error::ParseError, "Enclosed SRID #{srid_} is different from toplevel srid #{@cur_srid || '(unspecified)'}"
+          if srid && srid != @cur_srid
+            raise Error::ParseError, "Enclosed SRID #{srid} is different from toplevel srid #{@cur_srid || '(unspecified)'}"
           end
         else
-          @cur_has_z = has_z_
-          @cur_has_m = has_m_
+          @cur_has_z = has_z
+          @cur_has_m = has_m
           @cur_dims = 2 + (@cur_has_z ? 1 : 0) + (@cur_has_m ? 1 : 0)
-          @cur_srid = srid_
-          @cur_factory = @factory_generator.call(srid: @cur_srid, has_z_coordinate: has_z_, has_m_coordinate: has_m_)
+          @cur_srid = srid
+          @cur_factory = @factory_generator.call(srid: @cur_srid, has_z_coordinate: has_z, has_m_coordinate: has_m)
           if @cur_has_z && !@cur_factory.property(:has_z_coordinate)
             raise Error::ParseError, "Data has Z coordinates but the factory doesn't have Z coordinates"
           end
@@ -176,75 +180,71 @@ module RGeo
             raise Error::ParseError, "Data has M coordinates but the factory doesn't have M coordinates"
           end
         end
-        case type_code_
+        case type_code
         when 1
-          coords_ = _get_doubles(little_endian_, @cur_dims)
-          @cur_factory.point(*coords_)
+          coords = get_doubles(little_endian, @cur_dims)
+          @cur_factory.point(*coords)
         when 2
-          _parse_line_string(little_endian_)
+          parse_line_string(little_endian)
         when 3
-          interior_rings_ = (1.._get_integer(little_endian_)).map { _parse_line_string(little_endian_) }
-          exterior_ring_ = interior_rings_.shift || @cur_factory.linear_ring([])
-          @cur_factory.polygon(exterior_ring_, interior_rings_)
+          interior_rings = (1..get_integer(little_endian)).map { parse_line_string(little_endian) }
+          exterior_ring = interior_rings.shift || @cur_factory.linear_ring([])
+          @cur_factory.polygon(exterior_ring, interior_rings)
         when 4
-          @cur_factory.multi_point((1.._get_integer(little_endian_)).map { _parse_object(1) })
+          @cur_factory.multi_point((1..get_integer(little_endian)).map { parse_object(1) })
         when 5
-          @cur_factory.multi_line_string((1.._get_integer(little_endian_)).map { _parse_object(2) })
+          @cur_factory.multi_line_string((1..get_integer(little_endian)).map { parse_object(2) })
         when 6
-          @cur_factory.multi_polygon((1.._get_integer(little_endian_)).map { _parse_object(3) })
+          @cur_factory.multi_polygon((1..get_integer(little_endian)).map { parse_object(3) })
         when 7
-          @cur_factory.collection((1.._get_integer(little_endian_)).map { _parse_object(true) })
+          @cur_factory.collection((1..get_integer(little_endian)).map { parse_object(true) })
         else
-          raise Error::ParseError, "Unknown type value: #{type_code_}."
+          raise Error::ParseError, "Unknown type value: #{type_code}."
         end
       end
 
-      def _parse_line_string(little_endian_) # :nodoc:
-        count_ = _get_integer(little_endian_)
-        coords_ = _get_doubles(little_endian_, @cur_dims * count_)
-        @cur_factory.line_string((0...count_).map { |i_| @cur_factory.point(*coords_[@cur_dims * i_, @cur_dims]) })
-      end
-
-      def _start_scanner(data_) # :nodoc:
-        @_data = data_
-        @_len = data_.length
-        @_pos = 0
+      def parse_line_string(little_endian)
+        count = get_integer(little_endian)
+        coords = get_doubles(little_endian, @cur_dims * count)
+        @cur_factory.line_string((0...count).map { |i| @cur_factory.point(*coords[@cur_dims * i, @cur_dims]) })
       end
 
-      def _clean_scanner # :nodoc:
-        @_data = nil
+      def start_scanner(data)
+        @data = data
+        @len = data.length
+        @pos = 0
       end
 
-      def _bytes_remaining # :nodoc:
-        @_len - @_pos
+      def bytes_remaining
+        @len - @pos
       end
 
-      def _get_byte # :nodoc:
-        if @_pos + 1 > @_len
+      def get_byte
+        if @pos + 1 > @len
           raise Error::ParseError, "Not enough bytes left to fulfill 1 byte"
         end
-        str_ = @_data[@_pos, 1]
-        @_pos += 1
-        str_.unpack("C").first
+        str = @data[@pos, 1]
+        @pos += 1
+        str.unpack("C").first
       end
 
-      def _get_integer(little_endian_) # :nodoc:
-        if @_pos + 4 > @_len
+      def get_integer(little_endian)
+        if @pos + 4 > @len
           raise Error::ParseError, "Not enough bytes left to fulfill 1 integer"
         end
-        str_ = @_data[@_pos, 4]
-        @_pos += 4
-        str_.unpack("#{little_endian_ ? 'V' : 'N'}").first
+        str = @data[@pos, 4]
+        @pos += 4
+        str.unpack(little_endian ? "V" : "N").first
       end
 
-      def _get_doubles(little_endian_, count_) # :nodoc:
-        len_ = 8 * count_
-        if @_pos + len_ > @_len
-          raise Error::ParseError, "Not enough bytes left to fulfill #{count_} doubles"
+      def get_doubles(little_endian, count)
+        len = 8 * count
+        if @pos + len > @len
+          raise Error::ParseError, "Not enough bytes left to fulfill #{count} doubles"
         end
-        str_ = @_data[@_pos, len_]
-        @_pos += len_
-        str_.unpack("#{little_endian_ ? 'E' : 'G'}*")
+        str = @data[@pos, len]
+        @pos += len
+        str.unpack("#{little_endian ? 'E' : 'G'}*")
       end
     end
   end