rgeo 2.4.0 → 3.0.0

data/lib/rgeo/geos/ffi_feature_methods.rb

@@ -6,11 +6,15 @@
 #
 # -----------------------------------------------------------------------------
 
+require "ffi-geos"
+
 module RGeo
   module Geos
     module FFIGeometryMethods # :nodoc:
       include Feature::Instance
 
+      attr_reader :factory, :fg_geom, :_klasses
+
       def initialize(factory, fg_geom, klasses)
         @factory = factory
         @fg_geom = fg_geom
@@ -54,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
@@ -75,6 +74,14 @@ module RGeo
         Utils.ffi_compute_dimension(@fg_geom)
       end
 
+      def coordinate_dimension
+        factory.coordinate_dimension
+      end
+
+      def spatial_dimension
+        factory.spatial_dimension
+      end
+
       def geometry_type
         Feature::Geometry
       end
@@ -84,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
 
@@ -95,11 +100,9 @@ module RGeo
       end
 
       def boundary
-        if self.class == FFIGeometryCollectionImpl
-          nil
-        else
-          @factory.wrap_fg_geom(@fg_geom.boundary, nil)
-        end
+        @factory.wrap_fg_geom(@fg_geom.boundary, nil)
+      rescue ::Geos::GEOSException
+        raise Error::InvalidGeometry, "Operation not supported by GeometryCollection"
       end
 
       def as_text
@@ -117,28 +120,45 @@ module RGeo
         @fg_geom.empty?
       end
 
-      def is_empty?
-        warn "The is_empty? method is deprecated, please use the empty? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        empty?
-      end
-
       def simple?
         @fg_geom.simple?
       end
 
-      def is_simple?
-        warn "The is_simple? method is deprecated, please use the simple? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        simple?
+      def is_3d?
+        factory.property(:has_z_coordinate)
+      end
+
+      def measured?
+        factory.property(:has_m_coordinate)
+      end
+
+      def valid?
+        @fg_geom.valid?
+      end
+
+      def invalid_reason
+        # valid_detail gives solely the reason, or nil if valid, which is
+        # what we want.
+        fg_geom.valid_detail&.dig(:detail)&.force_encoding(Encoding::UTF_8)
+      end
+
+      # (see RGeo::ImplHelper::ValidityCheck#make_valid)
+      # Only available since GEOS 3.8+
+      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)
@@ -148,83 +168,55 @@ 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_level_2
+        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_level_1
+        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_level_2
+        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_level_2
+        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_level_2
+        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_level_1
+        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_level_2
+        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)
@@ -237,14 +229,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
@@ -256,18 +248,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
@@ -319,7 +311,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
 
@@ -348,14 +340,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
@@ -381,22 +374,12 @@ module RGeo
         @fg_geom.closed?
       end
 
-      def is_closed?
-        warn "The is_closed? method is deprecated, please use the closed? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        closed?
-      end
-
       def ring?
         @fg_geom.ring?
       end
 
-      def is_ring?
-        warn "The is_ring? method is deprecated, please use the ring? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        ring?
-      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
 
@@ -450,10 +433,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
@@ -463,7 +446,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
@@ -479,8 +462,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
@@ -498,7 +483,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|
@@ -515,35 +500,34 @@ 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
-        @hash ||= begin
-          hash = [@factory, geometry_type].hash
-          (0...num_geometries).inject(hash) do |h, i|
-            (1_664_525 * h + geometry_n(i).hash).hash
-          end
-        end
+        @hash ||= [@factory, geometry_type, *(0...num_geometries).map { |i| geometry_n(i) }].hash
       end
 
       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
@@ -581,11 +565,6 @@ module RGeo
         true
       end
 
-      def is_closed?
-        warn "The is_closed? method is deprecated, please use the closed? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        closed?
-      end
-
       def coordinates
         each.map(&:coordinates)
       end

data/lib/rgeo/geos/interface.rb

@@ -38,11 +38,6 @@ module RGeo
           ZMGeometryMethods === object && CAPIGeometryMethods === object.z_geometry)
       end
 
-      def is_capi_geos?(object)
-        warn "The is_capi_geos? method is deprecated, please use the capi_geos? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        capi_geos?(object)
-      end
-
       # Returns true if the given feature is an FFI GEOS feature, or if
       # the given factory is an FFI GEOS factory.
 
@@ -53,11 +48,6 @@ module RGeo
           ZMGeometryMethods === object && FFIGeometryMethods === object.z_geometry)
       end
 
-      def is_ffi_geos?(object)
-        warn "The is_ffi_geos? method is deprecated, please use the ffi_geos? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        ffi_geos?(object)
-      end
-
       # Returns true if the given feature is a GEOS feature, or if the given
       # factory is a GEOS factory. Does not distinguish between CAPI and FFI.
 
@@ -67,23 +57,17 @@ module RGeo
           ZMFactory === object || ZMGeometryMethods === object
       end
 
-      def is_geos?(object)
-        warn "The is_geos? method is deprecated, please use the geos? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        geos?(object)
-      end
-
       # Returns the GEOS library version as a string of the format "x.y.z".
       # Returns nil if GEOS is not available.
 
       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
@@ -116,13 +100,6 @@ module RGeo
       #   Specifies which native interface to use. Possible values are
       #   <tt>:capi</tt> and <tt>:ffi</tt>. The default is the value
       #   of the preferred_native_interface.
-      # [<tt>:uses_lenient_multi_polygon_assertions</tt>]
-      #   If set to true, assertion checking on MultiPolygon is disabled.
-      #   This may speed up creation of MultiPolygon objects, at the
-      #   expense of not doing the proper checking for OGC MultiPolygon
-      #   compliance. See RGeo::Feature::MultiPolygon for details on
-      #   the MultiPolygon assertions. Default is false. Also called
-      #   <tt>:lenient_multi_polygon_assertions</tt>.
       # [<tt>:buffer_resolution</tt>]
       #   The resolution of buffers around geometries created by this
       #   factory. This controls the number of line segments used to
@@ -134,19 +111,14 @@ module RGeo
       # [<tt>:srid</tt>]
       #   Set the SRID returned by geometries created by this factory.
       #   Default is 0.
-      # [<tt>:proj4</tt>]
-      #   The coordinate system in Proj4 format, either as a
-      #   CoordSys::Proj4 object or as a string or hash representing the
-      #   proj4 format. Optional.
       # [<tt>:coord_sys</tt>]
       #   The coordinate system in OGC form, either as a subclass of
       #   CoordSys::CS::CoordinateSystem, or as a string in WKT format.
-      #   Optional.
-      # [<tt>:srs_database</tt>]
-      #   Optional. If provided, the object should respond to #get and
-      #   #clear_cache. If both this and an SRID are
-      #   provided, they are used to look up the proj4 and coord_sys
-      #   objects from a spatial reference system database.
+      #   Optional. If not provided, but <tt>:srid</tt> is, a coord_sys
+      #   will be created using the CS::CONFIG.default_coord_sys_class.
+      #  [<tt>:coord_sys_class</tt>]
+      #    The coordinate system implementation to use if you do not want to
+      #    use the CS::CONFIG.default_coord_sys_class. Optional.
       # [<tt>:has_z_coordinate</tt>]
       #   Support <tt>z_coordinate</tt>. Default is false.
       # [<tt>:has_m_coordinate</tt>]
@@ -190,28 +162,17 @@ 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
-        end
-      end
+        return unless supported?
 
-      # Returns a Feature::FactoryGenerator that creates Geos-backed
-      # factories. The given options are used as the default options.
-      #
-      # A common case for this is to provide the <tt>:srs_database</tt>
-      # as a default. Then, the factory generator need only be passed
-      # an SRID and it will automatically fetch the appropriate Proj4
-      # and CoordSys objects.
+        native_interface = opts[:native_interface] || Geos.preferred_native_interface
 
-      def factory_generator(defaults = {})
-        proc { |c| factory(defaults.merge(c)) }
+        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
   end

data/lib/rgeo/geos/utils.rb

@@ -49,9 +49,9 @@ 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