rgeo 3.0.0.pre.rc.3 → 3.0.1

data/lib/rgeo/geos/ffi_factory.rb

@@ -9,11 +9,22 @@
 module RGeo
   module Geos
     # This the FFI-GEOS implementation of RGeo::Feature::Factory.
-
     class FFIFactory
       include Feature::Factory::Instance
       include ImplHelper::Utils
 
+      attr_reader :coordinate_dimension, :spatial_dimension, :_has_3d, :_auto_prepare
+
+      # Returns the SRID of geometries created by this factory.
+      attr_reader :srid
+
+      # Returns the resolution used by buffer calculations on geometries
+      # created by this factory
+      attr_reader :buffer_resolution
+
+      # See RGeo::Feature::Factory#coord_sys
+      attr_reader :coord_sys
+
       # Create a new factory. Returns nil if the FFI-GEOS implementation
       # is not supported.
       #
@@ -22,9 +33,11 @@ module RGeo
       def initialize(opts = {})
         @has_z = opts[:has_z_coordinate] ? true : false
         @has_m = opts[:has_m_coordinate] ? true : false
+
         if @has_z && @has_m
           raise Error::UnsupportedOperation, "GEOS cannot support both Z and M coordinates at the same time."
         end
+
         @coordinate_dimension = 2
         @coordinate_dimension += 1 if @has_z
         @coordinate_dimension += 1 if @has_m
@@ -43,6 +56,7 @@ module RGeo
           @wkt_writer = nil
         else
           @wkt_writer = ::Geos::WktWriter.new
+          @wkt_writer.output_dimensions = 2
           @wkt_writer.trim = true
           @wkt_generator = nil
         end
@@ -53,6 +67,7 @@ module RGeo
           @wkb_writer = nil
         else
           @wkb_writer = ::Geos::WkbWriter.new
+          @wkb_writer.output_dimensions = 2
           @wkb_generator = nil
         end
 
@@ -81,7 +96,6 @@ module RGeo
           @wkb_parser = nil
         end
       end
-      attr_reader :coordinate_dimension, :spatial_dimension
 
       # Standard object inspection output
 
@@ -91,12 +105,12 @@ module RGeo
 
       # Factory equivalence test.
 
-      def eql?(rhs)
-        rhs.is_a?(self.class) && @srid == rhs.srid &&
-          @has_z == rhs.property(:has_z_coordinate) &&
-          @has_m == rhs.property(:has_m_coordinate) &&
-          @buffer_resolution == rhs.property(:buffer_resolution) &&
-          @coord_sys.eql?(rhs.coord_sys)
+      def eql?(other)
+        other.is_a?(self.class) && @srid == other.srid &&
+          @has_z == other.property(:has_z_coordinate) &&
+          @has_m == other.property(:has_m_coordinate) &&
+          @buffer_resolution == other.property(:buffer_resolution) &&
+          @coord_sys.eql?(other.coord_sys)
       end
       alias == eql?
 
@@ -125,11 +139,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(
           has_z_coordinate: data["hasz"],
           has_m_coordinate: data["hasm"],
@@ -160,11 +172,9 @@ module RGeo
       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(
           has_z_coordinate: coder["has_z_coordinate"],
           has_m_coordinate: coder["has_m_coordinate"],
@@ -179,15 +189,6 @@ module RGeo
         )
       end
 
-      # Returns the SRID of geometries created by this factory.
-
-      attr_reader :srid
-
-      # Returns the resolution used by buffer calculations on geometries
-      # created by this factory
-
-      attr_reader :buffer_resolution
-
       # See RGeo::Feature::Factory#property
       def property(name_)
         case name_
@@ -296,10 +297,8 @@ module RGeo
         inner_rings = inner_rings.to_a unless inner_rings.is_a?(Array)
         return unless RGeo::Feature::LineString.check_type(outer_ring)
         outer_ring = create_fg_linear_ring(outer_ring.points)
-        inner_rings = inner_rings.map do |r|
-          return unless RGeo::Feature::LineString.check_type(r)
-          create_fg_linear_ring(r.points)
-        end
+        return unless inner_rings.all? { |r| RGeo::Feature::LineString.check_type(r) }
+        inner_rings = inner_rings.map { |r| create_fg_linear_ring(r.points) }
         inner_rings.compact!
         fg_geom = ::Geos::Utils.create_polygon(outer_ring, *inner_rings)
         FFIPolygonImpl.new(self, fg_geom, nil)
@@ -328,11 +327,16 @@ module RGeo
       def multi_point(elems)
         elems = elems.to_a unless elems.is_a?(Array)
         elems = elems.map do |elem|
-          elem = RGeo::Feature.cast(elem, self, RGeo::Feature::Point,
-            :force_new, :keep_subtype)
-          return unless elem
-          elem.detach_fg_geom
+          RGeo::Feature.cast(
+            elem,
+            self,
+            RGeo::Feature::Point,
+            :force_new,
+            :keep_subtype
+          )
         end
+        return unless elems.all?
+        elems = elems.map(&:detach_fg_geom)
         klasses = Array.new(elems.size, FFIPointImpl)
         fg_geom = ::Geos::Utils.create_collection(::Geos::GeomTypes::GEOS_MULTIPOINT, elems)
         FFIMultiPointImpl.new(self, fg_geom, klasses)
@@ -367,13 +371,9 @@ module RGeo
         FFIMultiPolygonImpl.new(self, fg_geom, klasses)
       end
 
-      # See RGeo::Feature::Factory#coord_sys
-
-      attr_reader :coord_sys
-
       # See RGeo::Feature::Factory#override_cast
 
-      def override_cast(original, ntype, flags)
+      def override_cast(_original, _ntype, _flags)
         false
         # TODO
       end
@@ -421,14 +421,13 @@ module RGeo
         klass.new(self, fg_geom, klasses)
       end
 
-      attr_reader :_has_3d # :nodoc:
-      attr_reader :_auto_prepare # :nodoc:
-
       def convert_to_fg_geometry(obj, type = nil)
-        if type && obj.factory != self
-          obj = Feature.cast(obj, self, type)
-        end
-        obj&.fg_geom
+        obj = Feature.cast(obj, self, type) if type && obj.factory != self
+
+        geom = obj&.fg_geom
+        raise RGeo::Error::InvalidGeometry, "Unable to cast the geometry to the FFI Factory" if geom.nil?
+
+        geom
       end
 
       def generate_wkt(geom)
@@ -450,6 +449,7 @@ module RGeo
       def write_for_marshal(geom)
         if Utils.ffi_supports_set_output_dimension || !@_has_3d
           wkb_writer = ::Geos::WkbWriter.new
+          wkb_writer.output_dimensions = 2
           wkb_writer.output_dimensions = 3 if @_has_3d
           wkb_writer.write(geom.fg_geom)
         else
@@ -464,6 +464,7 @@ module RGeo
       def write_for_psych(geom)
         if Utils.ffi_supports_set_output_dimension || !@_has_3d
           wkt_writer = ::Geos::WktWriter.new
+          wkt_writer.output_dimensions = 2
           wkt_writer.trim = true
           wkt_writer.output_dimensions = 3 if @_has_3d
           wkt_writer.write(geom.fg_geom)
@@ -480,14 +481,14 @@ module RGeo
 
       def create_fg_linear_ring(points)
         size = points.size
-        return if size == 1 || size == 2
+        return if size.between?(1, 2)
         if size > 0 && points.first != points.last
           points += [points.first]
           size += 1
         end
         cs = ::Geos::CoordinateSequence.new(size, 3)
+        return unless points.all? { |p| RGeo::Feature::Point.check_type(p) }
         points.each_with_index do |p, i|
-          return unless RGeo::Feature::Point.check_type(p)
           cs.set_x(i, p.x)
           cs.set_y(i, p.y)
           if @has_z

data/lib/rgeo/geos/ffi_feature_methods.rb

@@ -13,6 +13,8 @@ module RGeo
     module FFIGeometryMethods # :nodoc:
       include Feature::Instance
 
+      attr_reader :factory, :fg_geom, :_klasses
+
       def initialize(factory, fg_geom, klasses)
         @factory = factory
         @fg_geom = fg_geom
@@ -56,11 +58,6 @@ module RGeo
         @_klasses = nil
       end
 
-      attr_reader :factory
-      attr_reader :fg_geom
-
-      attr_reader :_klasses # :nodoc:
-
       def initialize_copy(orig)
         @factory = orig.factory
         @fg_geom = orig.fg_geom.clone
@@ -94,9 +91,7 @@ module RGeo
       end
 
       def prepare!
-        if @_fg_prep.is_a?(Integer)
-          @_fg_prep = ::Geos::PreparedGeometry.new(@fg_geom)
-        end
+        @_fg_prep = ::Geos::PreparedGeometry.new(@fg_geom) if @_fg_prep.is_a?(Integer)
         self
       end
 
@@ -149,20 +144,21 @@ module RGeo
 
       # (see RGeo::ImplHelper::ValidityCheck#make_valid)
       # Only available since GEOS 3.8+
-      def make_valid
-        @factory.wrap_fg_geom(@fg_geom.make_valid, nil)
-      rescue ::Geos::GEOSException
-        raise Error::UnsupportedOperation
-      end if ::Geos::FFIGeos.respond_to?(:GEOSMakeValid_r)
+      if ::Geos::FFIGeos.respond_to?(:GEOSMakeValid_r)
+        def make_valid
+          @factory.wrap_fg_geom(@fg_geom.make_valid, nil)
+        rescue ::Geos::GEOSException
+          raise Error::UnsupportedOperation
+        end
+      end
 
       def equals?(rhs)
         return false unless rhs.is_a?(RGeo::Feature::Instance)
         fg = factory.convert_to_fg_geometry(rhs)
-        if !fg
-          false
+
         # GEOS has a bug where empty geometries are not spatially equal
         # to each other. Work around this case first.
-        elsif fg.empty? && @fg_geom.empty?
+        if fg.empty? && @fg_geom.empty?
           true
         else
           @fg_geom.eql?(fg)
@@ -172,83 +168,54 @@ module RGeo
 
       def disjoint?(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        if fg
-          prep = request_prepared if Utils.ffi_supports_prepared_level_2
-          prep ? prep.disjoint?(fg) : @fg_geom.disjoint?(fg)
-        else
-          false
-        end
+        prep = request_prepared if Utils.ffi_supports_prepared_level2
+        prep ? prep.disjoint?(fg) : @fg_geom.disjoint?(fg)
       end
 
       def intersects?(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        if fg
-          prep = request_prepared if Utils.ffi_supports_prepared_level_1
-          prep ? prep.intersects?(fg) : @fg_geom.intersects?(fg)
-        else
-          false
-        end
+        prep = request_prepared if Utils.ffi_supports_prepared_level1
+        prep ? prep.intersects?(fg) : @fg_geom.intersects?(fg)
       end
 
       def touches?(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        if fg
-          prep = request_prepared if Utils.ffi_supports_prepared_level_2
-          prep ? prep.touches?(fg) : @fg_geom.touches?(fg)
-        else
-          false
-        end
+        prep = request_prepared if Utils.ffi_supports_prepared_level2
+        prep ? prep.touches?(fg) : @fg_geom.touches?(fg)
       end
 
       def crosses?(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        if fg
-          prep = request_prepared if Utils.ffi_supports_prepared_level_2
-          prep ? prep.crosses?(fg) : @fg_geom.crosses?(fg)
-        else
-          false
-        end
+        prep = request_prepared if Utils.ffi_supports_prepared_level2
+        prep ? prep.crosses?(fg) : @fg_geom.crosses?(fg)
       end
 
       def within?(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        if fg
-          prep = request_prepared if Utils.ffi_supports_prepared_level_2
-          prep ? prep.within?(fg) : @fg_geom.within?(fg)
-        else
-          false
-        end
+        prep = request_prepared if Utils.ffi_supports_prepared_level2
+        prep ? prep.within?(fg) : @fg_geom.within?(fg)
       end
 
       def contains?(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        if fg
-          prep = request_prepared if Utils.ffi_supports_prepared_level_1
-          prep ? prep.contains?(fg) : @fg_geom.contains?(fg)
-        else
-          false
-        end
+        prep = request_prepared if Utils.ffi_supports_prepared_level1
+        prep ? prep.contains?(fg) : @fg_geom.contains?(fg)
       end
 
       def overlaps?(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        if fg
-          prep = request_prepared if Utils.ffi_supports_prepared_level_2
-          prep ? prep.overlaps?(fg) : @fg_geom.overlaps?(fg)
-        else
-          false
-        end
+        prep = request_prepared if Utils.ffi_supports_prepared_level2
+        prep ? prep.overlaps?(fg) : @fg_geom.overlaps?(fg)
       end
 
       def relate?(rhs, pattern)
         fg = factory.convert_to_fg_geometry(rhs)
-        fg ? @fg_geom.relate_pattern(fg, pattern) : nil
+        @fg_geom.relate_pattern(fg, pattern)
       end
-      alias relate relate? # DEPRECATED
 
       def distance(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        fg ? @fg_geom.distance(fg) : nil
+        @fg_geom.distance(fg)
       end
 
       def buffer(distance)
@@ -261,14 +228,14 @@ module RGeo
 
       def intersection(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        fg ? @factory.wrap_fg_geom(@fg_geom.intersection(fg), nil) : nil
+        @factory.wrap_fg_geom(@fg_geom.intersection(fg), nil)
       end
 
       alias * intersection
 
       def union(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        fg ? @factory.wrap_fg_geom(@fg_geom.union(fg), nil) : nil
+        @factory.wrap_fg_geom(@fg_geom.union(fg), nil)
       end
 
       alias + union
@@ -280,18 +247,18 @@ module RGeo
 
       def difference(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        fg ? @factory.wrap_fg_geom(@fg_geom.difference(fg), nil) : nil
+        @factory.wrap_fg_geom(@fg_geom.difference(fg), nil)
       end
 
       alias - difference
 
       def sym_difference(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        fg ? @factory.wrap_fg_geom(@fg_geom.sym_difference(fg), nil) : nil
+        @factory.wrap_fg_geom(@fg_geom.sym_difference(fg), nil)
       end
 
-      def eql?(rhs)
-        rep_equals?(rhs)
+      def eql?(other)
+        rep_equals?(other)
       end
 
       def detach_fg_geom
@@ -343,7 +310,7 @@ module RGeo
       end
 
       def rep_equals?(rhs)
-        rhs.class == self.class && rhs.factory.eql?(@factory) &&
+        rhs.instance_of?(self.class) && rhs.factory.eql?(@factory) &&
           Utils.ffi_coord_seqs_equal?(rhs.fg_geom.coord_seq, @fg_geom.coord_seq, @factory._has_3d)
       end
 
@@ -372,14 +339,15 @@ module RGeo
         @fg_geom.num_points
       end
 
-      def point_n(n)
-        if n >= 0 && n < @fg_geom.num_points
-          coord_seq = @fg_geom.coord_seq
-          x = coord_seq.get_x(n)
-          y = coord_seq.get_y(n)
-          extra = @factory._has_3d ? [coord_seq.get_z(n)] : []
-          @factory.point(x, y, *extra)
-        end
+      def point_n(idx)
+        return unless idx >= 0 && idx < @fg_geom.num_points
+
+        coord_seq = @fg_geom.coord_seq
+        x = coord_seq.get_x(idx)
+        y = coord_seq.get_y(idx)
+        extra = @factory._has_3d ? [coord_seq.get_z(idx)] : []
+
+        @factory.point(x, y, *extra)
       end
 
       def start_point
@@ -410,7 +378,7 @@ module RGeo
       end
 
       def rep_equals?(rhs)
-        rhs.class == self.class && rhs.factory.eql?(@factory) &&
+        rhs.instance_of?(self.class) && rhs.factory.eql?(@factory) &&
           Utils.ffi_coord_seqs_equal?(rhs.fg_geom.coord_seq, @fg_geom.coord_seq, @factory._has_3d)
       end
 
@@ -464,10 +432,10 @@ module RGeo
         @fg_geom.num_interior_rings
       end
 
-      def interior_ring_n(n)
-        if n >= 0 && n < @fg_geom.num_interior_rings
-          @factory.wrap_fg_geom(@fg_geom.interior_ring_n(n), FFILinearRingImpl)
-        end
+      def interior_ring_n(idx)
+        return unless idx >= 0 && idx < @fg_geom.num_interior_rings
+
+        @factory.wrap_fg_geom(@fg_geom.interior_ring_n(idx), FFILinearRingImpl)
       end
 
       def interior_rings
@@ -477,7 +445,7 @@ module RGeo
       end
 
       def rep_equals?(rhs)
-        if rhs.class == self.class && rhs.factory.eql?(@factory) &&
+        if rhs.instance_of?(self.class) && rhs.factory.eql?(@factory) &&
           rhs.exterior_ring.rep_equals?(exterior_ring)
           sn = @fg_geom.num_interior_rings
           rn = rhs.num_interior_rings
@@ -493,8 +461,10 @@ module RGeo
 
       def hash
         @hash ||= begin
-          hash = Utils.ffi_coord_seq_hash(@fg_geom.exterior_ring.coord_seq,
-            [@factory, geometry_type].hash)
+          hash = Utils.ffi_coord_seq_hash(
+            @fg_geom.exterior_ring.coord_seq,
+            [@factory, geometry_type].hash
+          )
           @fg_geom.interior_rings.inject(hash) do |h, r|
             Utils.ffi_coord_seq_hash(r.coord_seq, h)
           end
@@ -512,7 +482,7 @@ module RGeo
       end
 
       def rep_equals?(rhs)
-        if rhs.class == self.class && rhs.factory.eql?(@factory)
+        if rhs.instance_of?(self.class) && rhs.factory.eql?(@factory)
           size = @fg_geom.num_geometries
           if size == rhs.num_geometries
             size.times do |n|
@@ -529,19 +499,24 @@ module RGeo
       end
       alias size num_geometries
 
-      def geometry_n(n)
-        if n >= 0 && n < @fg_geom.num_geometries
-          @factory.wrap_fg_geom(@fg_geom.get_geometry_n(n),
-            @_klasses ? @_klasses[n] : nil)
-        end
+      def geometry_n(idx)
+        return unless idx >= 0 && idx < @fg_geom.num_geometries
+
+        @factory.wrap_fg_geom(
+          @fg_geom.get_geometry_n(idx),
+          @_klasses ? @_klasses[idx] : nil
+        )
       end
 
-      def [](n)
-        n += @fg_geom.num_geometries if n < 0
-        if n >= 0 && n < @fg_geom.num_geometries
-          @factory.wrap_fg_geom(@fg_geom.get_geometry_n(n),
-            @_klasses ? @_klasses[n] : nil)
-        end
+      def [](idx)
+        idx += @fg_geom.num_geometries if idx < 0
+
+        return unless idx >= 0 && idx < @fg_geom.num_geometries
+
+        @factory.wrap_fg_geom(
+          @fg_geom.get_geometry_n(idx),
+          @_klasses ? @_klasses[idx] : nil
+        )
       end
 
       def hash
@@ -551,8 +526,7 @@ module RGeo
       def each
         if block_given?
           @fg_geom.num_geometries.times do |n|
-            yield @factory.wrap_fg_geom(@fg_geom.get_geometry_n(n),
-              @_klasses ? @_klasses[n] : nil)
+            yield @factory.wrap_fg_geom(@fg_geom.get_geometry_n(n), @_klasses ? @_klasses[n] : nil)
           end
           self
         else

data/lib/rgeo/geos/interface.rb

@@ -62,13 +62,12 @@ module RGeo
 
       def version
         unless defined?(@version)
-          if RGeo::Geos::CAPI_SUPPORTED
-            @version = RGeo::Geos::CAPIFactory._geos_version.freeze
-          elsif RGeo::Geos::FFI_SUPPORTED
-            @version = ::Geos::FFIGeos.GEOSversion.sub(/-CAPI-.*$/, "").freeze
-          else
-            @version = nil
-          end
+          @version =
+            if RGeo::Geos::CAPI_SUPPORTED
+              RGeo::Geos::CAPIFactory._geos_version.freeze
+            elsif RGeo::Geos::FFI_SUPPORTED
+              ::Geos::FFIGeos.GEOSversion.sub(/-CAPI-.*$/, "").freeze
+            end
         end
         @version
       end
@@ -163,15 +162,16 @@ module RGeo
       #   never automatically generates a prepared geometry (unless you
       #   generate one explicitly using the <tt>prepare!</tt> method).
       def factory(opts = {})
-        if supported?
-          native_interface = opts[:native_interface] || Geos.preferred_native_interface
-          if opts[:has_z_coordinate] && opts[:has_m_coordinate]
-            ZMFactory.new(opts)
-          elsif native_interface == :ffi
-            FFIFactory.new(opts)
-          else
-            CAPIFactory.create(opts)
-          end
+        return unless supported?
+
+        native_interface = opts[:native_interface] || Geos.preferred_native_interface
+
+        if opts[:has_z_coordinate] && opts[:has_m_coordinate]
+          ZMFactory.new(opts)
+        elsif native_interface == :ffi
+          FFIFactory.new(opts)
+        else
+          CAPIFactory.create(opts)
         end
       end
     end

data/lib/rgeo/geos/utils.rb

@@ -49,17 +49,17 @@ module RGeo
           result
         end
 
-        def ffi_coord_seq_hash(cs, hash = 0)
-          (0...cs.length).inject(hash) do |h, i|
-            [hash, cs.get_x(i), cs.get_y(i), cs.get_z(i)].hash
+        def ffi_coord_seq_hash(coord_seq, init_hash = 0)
+          (0...coord_seq.length).inject(init_hash) do |hash, i|
+            [hash, coord_seq.get_x(i), coord_seq.get_y(i), coord_seq.get_z(i)].hash
           end
         end
 
-        def ffi_supports_prepared_level_1
+        def ffi_supports_prepared_level1
           FFI_SUPPORTED && ::Geos::FFIGeos.respond_to?(:GEOSPreparedContains_r)
         end
 
-        def ffi_supports_prepared_level_2
+        def ffi_supports_prepared_level2
           FFI_SUPPORTED && ::Geos::FFIGeos.respond_to?(:GEOSPreparedDisjoint_r)
         end