rgeo 3.0.0.pre.rc.3 → 3.0.1

data/lib/rgeo/geos/zm_factory.rb

@@ -9,7 +9,6 @@
 module RGeo
   module Geos
     # A factory for Geos that handles both Z and M.
-
     class ZMFactory
       include Feature::Factory::Instance
       include ImplHelper::Utils
@@ -60,33 +59,37 @@ module RGeo
         end
 
         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
+        @wkt_generator =
+          case wkt_generator
+          when Hash
+            WKRep::WKTGenerator.new(wkt_generator)
+          else
+            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
+        @wkb_generator =
+          case wkb_generator
+          when Hash
+            WKRep::WKBGenerator.new(wkb_generator)
+          else
+            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
+        @wkt_parser =
+          case wkt_parser
+          when Hash
+            WKRep::WKTParser.new(self, wkt_parser)
+          else
+            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
+        @wkb_parser =
+          case wkb_parser
+          when Hash
+            WKRep::WKBParser.new(self, wkb_parser)
+          else
+            WKRep::WKBParser.new(self)
+          end
       end
 
       # Marshal support
@@ -108,11 +111,9 @@ module RGeo
       end
 
       def marshal_load(data) # :nodoc:
-        if (coord_sys_data = data["cs"])
-          coord_sys = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data)
-        else
-          coord_sys = nil
-        end
+        cs_class = CoordSys::CONFIG.default_coord_sys_class
+        coord_sys = data["cs"]&.then { |cs| cs_class.create_from_wkt(cs) }
+
         initialize(
           native_interface: (data["nffi"] ? :ffi : :capi),
           has_z_coordinate: data["hasz"],
@@ -139,17 +140,16 @@ module RGeo
         coder["wkb_parser"] = @wkb_parser.properties
         coder["auto_prepare"] = @zfactory.property(:auto_prepare).to_s
         coder["native_interface"] = @zfactory.is_a?(FFIFactory) ? "ffi" : "capi"
-        if (coord_sys = @zfactory.coord_sys)
-          coder["coord_sys"] = coord_sys.to_wkt
-        end
+
+        return unless (coord_sys = @zfactory.coord_sys)
+
+        coder["coord_sys"] = coord_sys.to_wkt
       end
 
       def init_with(coder) # :nodoc:
-        if (coord_sys_data = coder["cs"])
-          coord_sys = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data.to_s)
-        else
-          coord_sys = nil
-        end
+        cs_class = CoordSys::CONFIG.default_coord_sys_class
+        coord_sys = coder["cs"]&.then { |cs| cs_class.create_from_wkt(cs) }
+
         initialize(
           native_interface: coder["native_interface"] == "ffi" ? :ffi : :capi,
           has_z_coordinate: coder["has_z_coordinate"],
@@ -192,8 +192,8 @@ module RGeo
 
       # Factory equivalence test.
 
-      def eql?(rhs)
-        rhs.is_a?(ZMFactory) && rhs.z_factory == @zfactory
+      def eql?(other)
+        other.is_a?(ZMFactory) && other.z_factory == @zfactory
       end
       alias == eql?
 
@@ -227,7 +227,11 @@ module RGeo
       # See RGeo::Feature::Factory#point
 
       def point(x, y, z = 0, m = 0)
-        create_feature(ZMPointImpl, @zfactory.point(x, y, z), @mfactory.point(x, y, m))
+        create_feature(
+          ZMPointImpl,
+          @zfactory.point(x, y, z),
+          @mfactory.point(x, y, m)
+        )
       end
 
       # See RGeo::Feature::Factory#line_string
@@ -251,7 +255,11 @@ module RGeo
       # See RGeo::Feature::Factory#polygon
 
       def polygon(outer_ring, inner_rings = nil)
-        create_feature(ZMPolygonImpl, @zfactory.polygon(outer_ring, inner_rings), @mfactory.polygon(outer_ring, inner_rings))
+        create_feature(
+          ZMPolygonImpl,
+          @zfactory.polygon(outer_ring, inner_rings),
+          @mfactory.polygon(outer_ring, inner_rings)
+        )
       end
 
       # See RGeo::Feature::Factory#collection

data/lib/rgeo/geos/zm_feature_methods.rb

@@ -128,7 +128,6 @@ module RGeo
       def relate?(rhs, pattern)
         @zgeometry.relate?(RGeo::Feature.cast(rhs, self).z_geometry, pattern)
       end
-      alias relate relate? # DEPRECATED
 
       def distance(rhs)
         @zgeometry.distance(RGeo::Feature.cast(rhs, self).z_geometry)
@@ -159,12 +158,19 @@ module RGeo
 
       def sym_difference(rhs)
         rhs = RGeo::Feature.cast(rhs, self)
-        @factory.create_feature(nil, @zgeometry.sym_difference(rhs.z_geometry), @mgeometry.sym_difference(rhs.m_geometry))
+        @factory.create_feature(
+          nil,
+          @zgeometry.sym_difference(rhs.z_geometry),
+          @mgeometry.sym_difference(rhs.m_geometry)
+        )
       end
 
       def rep_equals?(rhs)
         rhs = RGeo::Feature.cast(rhs, self)
-        rhs.is_a?(self.class) && @factory.eql?(rhs.factory) && @zgeometry.rep_equals?(rhs.z_geometry) && @mgeometry.rep_equals?(rhs.m_geometry)
+        rhs.is_a?(self.class) &&
+          @factory.eql?(rhs.factory) &&
+          @zgeometry.rep_equals?(rhs.z_geometry) &&
+          @mgeometry.rep_equals?(rhs.m_geometry)
       end
 
       alias eql? rep_equals?
@@ -250,8 +256,8 @@ module RGeo
         @zgeometry.num_points
       end
 
-      def point_n(n)
-        @factory.create_feature(ZMPointImpl, @zgeometry.point_n(n), @mgeometry.point_n(n))
+      def point_n(idx)
+        @factory.create_feature(ZMPointImpl, @zgeometry.point_n(idx), @mgeometry.point_n(idx))
       end
 
       def points
@@ -290,8 +296,8 @@ module RGeo
         @zgeometry.num_interior_rings
       end
 
-      def interior_ring_n(n)
-        @factory.create_feature(ZMLineStringImpl, @zgeometry.interior_ring_n(n), @mgeometry.interior_ring_n(n))
+      def interior_ring_n(idx)
+        @factory.create_feature(ZMLineStringImpl, @zgeometry.interior_ring_n(idx), @mgeometry.interior_ring_n(idx))
       end
 
       def interior_rings
@@ -315,8 +321,8 @@ module RGeo
       end
       alias size num_geometries
 
-      def geometry_n(n)
-        @factory.create_feature(nil, @zgeometry.geometry_n(n), @mgeometry.geometry_n(n))
+      def geometry_n(idx)
+        @factory.create_feature(nil, @zgeometry.geometry_n(idx), @mgeometry.geometry_n(idx))
       end
       alias [] geometry_n
 

data/lib/rgeo/impl_helper/basic_geometry_collection_methods.rb

@@ -27,12 +27,12 @@ module RGeo
         @elements.size
       end
 
-      def geometry_n(n)
-        n < 0 ? nil : @elements[n]
+      def geometry_n(idx)
+        idx < 0 ? nil : @elements[idx]
       end
 
-      def [](n)
-        @elements[n]
+      def [](idx)
+        @elements[idx]
       end
 
       def each(&block)

data/lib/rgeo/impl_helper/basic_geometry_methods.rb

@@ -52,8 +52,7 @@ module RGeo
         @factory = obj.factory
       end
 
-      def init_geometry
-      end
+      def init_geometry; end
     end
   end
 end

data/lib/rgeo/impl_helper/basic_line_string_methods.rb

@@ -19,9 +19,7 @@ module RGeo
         # LineStrings in general need to check that there's not one point
         # GEOS doesn't allow instantiation of single point LineStrings so
         # we should handle it.
-        if @points.size == 1
-          raise Error::InvalidGeometry, "LineString Cannot Have 1 Point"
-        end
+        raise Error::InvalidGeometry, "LineString Cannot Have 1 Point" if @points.size == 1
         init_geometry
       end
 
@@ -29,8 +27,8 @@ module RGeo
         @points.size
       end
 
-      def point_n(n)
-        n < 0 ? nil : @points[n]
+      def point_n(idx)
+        idx < 0 ? nil : @points[idx]
       end
 
       def points
@@ -64,10 +62,9 @@ module RGeo
       end
 
       def closed?
-        unless defined?(@closed)
-          @closed = @points.size > 2 && @points.first == @points.last
-        end
-        @closed
+        return @closed if defined?(@closed)
+
+        @closed = @points.size > 2 && @points.first == @points.last
       end
 
       def ring?
@@ -111,15 +108,15 @@ module RGeo
       def point_intersect_segment?(point, start_point, end_point)
         return false unless point_collinear?(point, start_point, end_point)
 
-        if start_point.x != end_point.x
-          between_coordinate?(point.x, start_point.x, end_point.x)
-        else
+        if start_point.x == end_point.x
           between_coordinate?(point.y, start_point.y, end_point.y)
+        else
+          between_coordinate?(point.x, start_point.x, end_point.x)
         end
       end
 
-      def point_collinear?(a, b, c)
-        (b.x - a.x) * (c.y - a.y) == (c.x - a.x) * (b.y - a.y)
+      def point_collinear?(pt1, pt2, pt3)
+        (pt2.x - pt1.x) * (pt3.y - pt1.y) == (pt3.x - pt1.x) * (pt2.y - pt1.y)
       end
 
       def between_coordinate?(coord, start_coord, end_coord)
@@ -137,9 +134,7 @@ module RGeo
       def initialize(factory, start, stop)
         self.factory = factory
         cstart = Feature.cast(start, factory, Feature::Point)
-        unless cstart
-          raise Error::InvalidGeometry, "Could not cast start: #{start}"
-        end
+        raise Error::InvalidGeometry, "Could not cast start: #{start}" unless cstart
         cstop = Feature.cast(stop, factory, Feature::Point)
         raise Error::InvalidGeometry, "Could not cast end: #{stop}" unless cstop
         @points = [cstart, cstop]
@@ -158,9 +153,7 @@ module RGeo
     module BasicLinearRingMethods # :nodoc:
       def initialize(factory, points)
         super
-        unless @points.size >= 4 || @points.size == 0
-          raise Error::InvalidGeometry, "LinearRings must have 0 or >= 4 points"
-        end
+        raise Error::InvalidGeometry, "LinearRings must have 0 or >= 4 points" if @points.size.between?(1, 3)
       end
 
       def geometry_type
@@ -176,10 +169,11 @@ module RGeo
       # Close ring if necessary.
       def init_geometry
         super
-        if @points.size > 0
-          @points << @points.first if @points.first != @points.last
-          @points = @points.chunk { |x| x }.map(&:first)
-        end
+
+        return if @points.empty?
+
+        @points << @points.first if @points.first != @points.last
+        @points = @points.chunk { |x| x }.map(&:first)
       end
     end
   end

data/lib/rgeo/impl_helper/basic_point_methods.rb

@@ -15,9 +15,7 @@ module RGeo
         @y = y.to_f
         @z = factory.property(:has_z_coordinate) ? extra.shift.to_f : nil
         @m = factory.property(:has_m_coordinate) ? extra.shift.to_f : nil
-        if extra.size > 0
-          raise ArgumentError, "Too many arguments for point initializer"
-        end
+        raise ArgumentError, "Too many arguments for point initializer" unless extra.empty?
         init_geometry
       end
 

data/lib/rgeo/impl_helper/basic_polygon_methods.rb

@@ -12,14 +12,10 @@ module RGeo
       def initialize(factory, exterior_ring, interior_rings)
         self.factory = factory
         @exterior_ring = Feature.cast(exterior_ring, factory, Feature::LinearRing)
-        unless @exterior_ring
-          raise Error::InvalidGeometry, "Failed to cast exterior ring #{exterior_ring}"
-        end
+        raise Error::InvalidGeometry, "Failed to cast exterior ring #{exterior_ring}" unless @exterior_ring
         @interior_rings = (interior_rings || []).map do |elem|
           elem = Feature.cast(elem, factory, Feature::LinearRing)
-          unless elem
-            raise Error::InvalidGeometry, "Could not cast interior ring #{elem}"
-          end
+          raise Error::InvalidGeometry, "Could not cast interior ring #{elem}" unless elem
           elem
         end
         init_geometry
@@ -33,8 +29,8 @@ module RGeo
         @interior_rings.size
       end
 
-      def interior_ring_n(n)
-        n < 0 ? nil : @interior_rings[n]
+      def interior_ring_n(idx)
+        idx < 0 ? nil : @interior_rings[idx]
       end
 
       def interior_rings
@@ -61,11 +57,14 @@ module RGeo
       end
 
       def rep_equals?(rhs)
-        if rhs.is_a?(self.class) && rhs.factory.eql?(@factory) && @exterior_ring.rep_equals?(rhs.exterior_ring) && @interior_rings.size == rhs.num_interior_rings
-          rhs.interior_rings.each_with_index { |r, i| return false unless @interior_rings[i].rep_equals?(r) }
-        else
-          false
-        end
+        proper_match = rhs.is_a?(self.class) &&
+          rhs.factory.eql?(@factory) &&
+          @exterior_ring.rep_equals?(rhs.exterior_ring) &&
+          @interior_rings.size == rhs.num_interior_rings
+
+        return false unless proper_match
+
+        rhs.interior_rings.each_with_index { |r, i| return false unless @interior_rings[i].rep_equals?(r) }
       end
 
       def hash
@@ -80,7 +79,8 @@ module RGeo
         if Feature::Point === rhs
           contains_point?(rhs)
         else
-          raise(Error::UnsupportedOperation,
+          raise(
+            Error::UnsupportedOperation,
             "Method Polygon#contains? is only defined for Point"
           )
         end
@@ -90,7 +90,7 @@ module RGeo
 
       def contains_point?(point)
         ring_encloses_point?(@exterior_ring, point) &&
-          !@interior_rings.any? do |exclusion|
+          @interior_rings.none? do |exclusion|
             ring_encloses_point?(exclusion, point, on_border_return: true)
           end
       end
@@ -114,7 +114,6 @@ module RGeo
         encloses_point
       end
 
-
       def copy_state_from(obj)
         super
         @exterior_ring = obj.exterior_ring

data/lib/rgeo/impl_helper/utils.rb

@@ -18,20 +18,14 @@ module RGeo
       # multiple times with different values and others pass the data
       # to a CAPI or FFI.
       def self.setup_coord_sys(srid, coord_sys, coord_sys_class)
-        unless coord_sys_class.is_a?(Class)
-          coord_sys_class = CoordSys::CONFIG.default_coord_sys_class
-        end
+        coord_sys_class = CoordSys::CONFIG.default_coord_sys_class unless coord_sys_class.is_a?(Class)
 
-        if coord_sys.is_a?(String)
-          coord_sys = coord_sys_class.create_from_wkt(coord_sys)
-        end
+        coord_sys = coord_sys_class.create_from_wkt(coord_sys) if coord_sys.is_a?(String)
 
         srid ||= coord_sys.authority_code if coord_sys
         srid = srid.to_i
         # Create a coord sys based on the SRID if one was not given
-        if coord_sys.nil? && srid != 0
-          coord_sys = coord_sys_class.create(srid)
-        end
+        coord_sys = coord_sys_class.create(srid) if coord_sys.nil? && srid != 0
 
         { coord_sys: coord_sys, srid: srid }
       end

data/lib/rgeo/impl_helper/valid_op.rb

@@ -181,12 +181,12 @@ module RGeo
 
       # Checks that the given point has valid coordinates.
       #
-      # @param pt [RGeo::Feature::Point]
+      # @param point [RGeo::Feature::Point]
       #
       # @return [String] invalid_reason
-      def check_invalid_coordinate(pt)
-        x = pt.x
-        y = pt.y
+      def check_invalid_coordinate(point)
+        x = point.x
+        y = point.y
         return if x.finite? && y.finite? && x.real? && y.real?
 
         Error::INVALID_COORDINATE
@@ -265,9 +265,7 @@ module RGeo
 
         poly.interior_rings.each do |interior|
           test_pt = interior.start_point
-          unless shell.contains?(test_pt) || poly.exterior_ring.contains?(test_pt)
-            return Error::HOLE_OUTSIDE_SHELL
-          end
+          return Error::HOLE_OUTSIDE_SHELL unless shell.contains?(test_pt) || poly.exterior_ring.contains?(test_pt)
         end
 
         nil
@@ -322,27 +320,25 @@ module RGeo
 
       # Checks that polygons do not intersect in a multipolygon.
       #
-      # @param mp [RGeo::Feature::MultiPolygon]
+      # @param mpoly [RGeo::Feature::MultiPolygon]
       #
       # @return [String] invalid_reason
-      def check_consistent_area_mp(mp)
-        mp.geometries.combination(2) do |p1, p2|
-          if p1.exterior_ring.crosses?(p2.exterior_ring)
-            return Error::SELF_INTERSECTION
-          end
+      def check_consistent_area_mp(mpoly)
+        mpoly.geometries.combination(2) do |p1, p2|
+          return Error::SELF_INTERSECTION if p1.exterior_ring.crosses?(p2.exterior_ring)
         end
         nil
       end
 
       # Checks that individual polygons within a multipolygon are not nested.
       #
-      # @param mp [RGeo::Feature::MultiPolygon]
+      # @param mpoly [RGeo::Feature::MultiPolygon]
       #
       # @return [String] invalid_reason
-      def check_shells_not_nested(mp)
+      def check_shells_not_nested(mpoly)
         # Since we've passed the consistent area test, we can just check
         # that one point lies in the other.
-        mp.geometries.combination(2) do |p1, p2|
+        mpoly.geometries.combination(2) do |p1, p2|
           if p1.contains?(p2.exterior_ring.start_point) || p2.contains?(p1.exterior_ring.start_point)
             return Error::NESTED_SHELLS
           end

data/lib/rgeo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RGeo
-  VERSION = "3.0.0-rc.3"
+  VERSION = "3.0.1"
 end

data/lib/rgeo/wkrep/wkb_generator.rb

@@ -39,7 +39,6 @@ module RGeo
     # [<tt>:little_endian</tt>]
     #   If true, output little endian (NDR) byte order. If false, output
     #   big endian (XDR), or network byte order. Default is false.
-
     class WKBGenerator
       # :stopdoc:
       TYPE_CODES = {
@@ -107,7 +106,7 @@ module RGeo
           has_m = false
         end
         result = Result.new(has_z, has_m)
-        generate_feature(obj, result, true)
+        generate_feature(obj, result, toplevel: true)
         result.emit(@hex_format)
       end
 
@@ -126,7 +125,7 @@ module RGeo
 
         def emit(hex_format)
           str = @buffer.join
-          hex_format ? str.unpack("H*")[0] : str
+          hex_format ? str.unpack1("H*") : str
         end
 
         def z?
@@ -139,79 +138,75 @@ module RGeo
       end
       private_constant :Result
 
-      def emit_byte(value, rv)
-        rv << [value].pack("C")
+      def emit_byte(value, rval)
+        rval << [value].pack("C")
       end
 
-      def emit_integer(value, rv)
-        rv << [value].pack(@little_endian ? "V" : "N")
+      def emit_integer(value, rval)
+        rval << [value].pack(@little_endian ? "V" : "N")
       end
 
-      def emit_doubles(array, rv)
-        rv << array.pack(@little_endian ? "E*" : "G*")
+      def emit_doubles(array, rval)
+        rval << array.pack(@little_endian ? "E*" : "G*")
       end
 
-      def emit_line_string_coords(obj, rv)
+      def emit_line_string_coords(obj, rval)
         array = []
-        obj.points.each { |pt| point_coords(pt, rv, array) }
-        emit_integer(obj.num_points, rv)
-        emit_doubles(array, rv)
+        obj.points.each { |pt| point_coords(pt, rval, array) }
+        emit_integer(obj.num_points, rval)
+        emit_doubles(array, rval)
       end
 
-      def point_coords(obj, rv, array = [])
+      def point_coords(obj, rval, array = [])
         array << obj.x
         array << obj.y
-        array << obj.z if rv.z?
-        array << obj.m if rv.m?
+        array << obj.z if rval.z?
+        array << obj.m if rval.m?
         array
       end
 
-      def generate_feature(obj, rv, toplevel = false)
-        emit_byte(@little_endian ? 1 : 0, rv)
+      def generate_feature(obj, rval, toplevel: false)
+        emit_byte(@little_endian ? 1 : 0, rval)
         type = obj.geometry_type
         type_code = TYPE_CODES[type]
-        unless type_code
-          raise Error::ParseError, "Unrecognized Geometry Type: #{type}"
-        end
+        raise Error::ParseError, "Unrecognized Geometry Type: #{type}" unless type_code
         emit_srid = false
-        if @type_format == :ewkb
-          type_code |= 0x80000000 if rv.z?
-          type_code |= 0x40000000 if rv.m?
+        case @type_format
+        when :ewkb
+          type_code |= 0x80000000 if rval.z?
+          type_code |= 0x40000000 if rval.m?
           if @emit_ewkb_srid && toplevel
             type_code |= 0x20000000
             emit_srid = true
           end
-        elsif @type_format == :wkb12
-          type_code += 1000 if rv.z?
-          type_code += 2000 if rv.m?
+        when :wkb12
+          type_code += 1000 if rval.z?
+          type_code += 2000 if rval.m?
         end
-        emit_integer(type_code, rv)
-        emit_integer(obj.srid, rv) if emit_srid
+        emit_integer(type_code, rval)
+        emit_integer(obj.srid, rval) if emit_srid
+        type_is_collection = [
+          Feature::GeometryCollection,
+          Feature::MultiPoint,
+          Feature::MultiLineString,
+          Feature::MultiPolygon
+        ].include?(type)
         if type == Feature::Point
-          emit_doubles(point_coords(obj, rv), rv)
+          emit_doubles(point_coords(obj, rval), rval)
         elsif type.subtype_of?(Feature::LineString)
-          emit_line_string_coords(obj, rv)
+          emit_line_string_coords(obj, rval)
         elsif type == Feature::Polygon
           exterior_ring = obj.exterior_ring
           if exterior_ring.empty?
-            emit_integer(0, rv)
+            emit_integer(0, rval)
           else
-            emit_integer(1 + obj.num_interior_rings, rv)
-            emit_line_string_coords(exterior_ring, rv)
-            obj.interior_rings.each { |r| emit_line_string_coords(r, rv) }
+            emit_integer(1 + obj.num_interior_rings, rval)
+            emit_line_string_coords(exterior_ring, rval)
+            obj.interior_rings.each { |r| emit_line_string_coords(r, rval) }
           end
-        elsif type == Feature::GeometryCollection
-          emit_integer(obj.num_geometries, rv)
-          obj.each { |g| generate_feature(g, rv) }
-        elsif type == Feature::MultiPoint
-          emit_integer(obj.num_geometries, rv)
-          obj.each { |g| generate_feature(g, rv) }
-        elsif type == Feature::MultiLineString
-          emit_integer(obj.num_geometries, rv)
-          obj.each { |g| generate_feature(g, rv) }
-        elsif type == Feature::MultiPolygon
-          emit_integer(obj.num_geometries, rv)
-          obj.each { |g| generate_feature(g, rv) }
+        elsif type_is_collection
+          emit_integer(obj.num_geometries, rval)
+          obj.each { |g| generate_feature(g, rval) }
         end
       end
     end