rgeo 2.3.1 → 3.0.1

data/lib/rgeo/geos/capi_feature_classes.rb

@@ -6,19 +6,30 @@
 #
 # -----------------------------------------------------------------------------
 
+require_relative "../impl_helper/validity_check"
+
 module RGeo
   module Geos
-    module CAPIGeometryMethods # :nodoc:
+    module CAPIGeometryMethods
       include Feature::Instance
 
-      def is_empty? # rubocop:disable Naming/PredicateName
-        warn "The is_empty? method is deprecated, please use the empty? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        empty?
+      def coordinate_dimension
+        dim = 2
+        dim += 1 if factory.supports_z?
+        dim += 1 if factory.supports_m?
+        dim
+      end
+
+      def spatial_dimension
+        factory.supports_z? ? 3 : 2
       end
 
-      def is_simple? # rubocop:disable Naming/PredicateName
-        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.supports_z?
+      end
+
+      def measured?
+        factory.supports_m?
       end
 
       def inspect
@@ -60,44 +71,33 @@ module RGeo
       alias to_s as_text
     end
 
-    module CAPIMultiLineStringMethods # :nodoc:
-      def is_closed? # rubocop:disable Naming/PredicateName
-        warn "The is_closed? method is deprecated, please use the closed? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        closed?
-      end
-    end
-
-    module CAPILineStringMethods # :nodoc:
-      def is_closed? # rubocop:disable Naming/PredicateName
-        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 is_ring? # rubocop:disable Naming/PredicateName
-        warn "The is_ring? method is deprecated, please use the ring? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
-        ring?
-      end
-    end
-
     module CAPIGeometryCollectionMethods # :nodoc:
       include Enumerable
     end
 
-    class CAPIGeometryImpl # :nodoc:
+    class CAPIGeometryImpl
+      include Feature::Geometry
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
     end
 
-    class CAPIPointImpl # :nodoc:
+    class CAPIPointImpl
+      include Feature::Point
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPIPointMethods
     end
 
-    class CAPILineStringImpl  # :nodoc:
+    class CAPILineStringImpl
+      include Feature::LineString
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPILineStringMethods
     end
 
-    class CAPILinearRingImpl  # :nodoc:
+    class CAPILinearRingImpl
+      include Feature::LinearRing
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPILineStringMethods
       include CAPILinearRingMethods
@@ -107,38 +107,52 @@ module RGeo
       end
     end
 
-    class CAPILineImpl # :nodoc:
+    class CAPILineImpl
+      include Feature::Line
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPILineStringMethods
       include CAPILineMethods
     end
 
-    class CAPIPolygonImpl # :nodoc:
+    class CAPIPolygonImpl
+      include Feature::Polygon
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPIPolygonMethods
     end
 
-    class CAPIGeometryCollectionImpl # :nodoc:
+    class CAPIGeometryCollectionImpl
+      include Feature::GeometryCollection
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPIGeometryCollectionMethods
     end
 
-    class CAPIMultiPointImpl # :nodoc:
+    class CAPIMultiPointImpl
+      include Feature::MultiPoint
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPIGeometryCollectionMethods
       include CAPIMultiPointMethods
     end
 
-    class CAPIMultiLineStringImpl # :nodoc:
+    class CAPIMultiLineStringImpl
+      include Feature::MultiLineString
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPIGeometryCollectionMethods
       include CAPIMultiLineStringMethods
     end
 
-    class CAPIMultiPolygonImpl # :nodoc:
+    class CAPIMultiPolygonImpl
+      include Feature::MultiPolygon
+      include ImplHelper::ValidityCheck
       include CAPIGeometryMethods
       include CAPIGeometryCollectionMethods
       include CAPIMultiPolygonMethods
     end
+
+    ImplHelper::ValidityCheck.override_classes
   end
 end

data/lib/rgeo/geos/ffi_factory.rb

@@ -9,104 +9,91 @@
 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.
       #
       # See RGeo::Geos.factory for a list of supported options.
 
       def initialize(opts = {})
-        # Main flags
-        @uses_lenient_multi_polygon_assertions = opts[:uses_lenient_assertions] ||
-          opts[:lenient_multi_polygon_assertions] || opts[:uses_lenient_multi_polygon_assertions]
         @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
+        @spatial_dimension = @has_z ? 3 : 2
+
         @_has_3d = @has_z || @has_m
         @buffer_resolution = opts[:buffer_resolution].to_i
         @buffer_resolution = 1 if @buffer_resolution < 1
-        @_auto_prepare = opts[:auto_prepare] == :disabled ? false : true
+        @_auto_prepare = opts[:auto_prepare] != :disabled
 
         # Interpret the generator options
-        wkt_generator_ = opts[:wkt_generator]
-        case wkt_generator_
-        when :geos
-          @wkt_writer = ::Geos::WktWriter.new
-          @wkt_generator = nil
+        wkt_generator = opts[:wkt_generator]
+        case wkt_generator
         when Hash
-          @wkt_generator = WKRep::WKTGenerator.new(wkt_generator_)
+          @wkt_generator = WKRep::WKTGenerator.new(wkt_generator)
           @wkt_writer = nil
         else
-          @wkt_generator = WKRep::WKTGenerator.new(convert_case: :upper)
-          @wkt_writer = nil
+          @wkt_writer = ::Geos::WktWriter.new
+          @wkt_writer.output_dimensions = 2
+          @wkt_writer.trim = true
+          @wkt_generator = nil
         end
-        wkb_generator_ = opts[:wkb_generator]
-        case wkb_generator_
-        when :geos
-          @wkb_writer = ::Geos::WkbWriter.new
-          @wkb_generator = nil
+        wkb_generator = opts[:wkb_generator]
+        case wkb_generator
         when Hash
-          @wkb_generator = WKRep::WKBGenerator.new(wkb_generator_)
+          @wkb_generator = WKRep::WKBGenerator.new(wkb_generator)
           @wkb_writer = nil
         else
-          @wkb_generator = WKRep::WKBGenerator.new
-          @wkb_writer = nil
+          @wkb_writer = ::Geos::WkbWriter.new
+          @wkb_writer.output_dimensions = 2
+          @wkb_generator = nil
         end
 
-        # Coordinate system (srid, proj4, and coord_sys)
-        @srid = opts[:srid]
-        @proj4 = opts[:proj4]
-        if @proj4 && CoordSys.check!(:proj4)
-          if @proj4.is_a?(String) || @proj4.is_a?(Hash)
-            @proj4 = CoordSys::Proj4.create(@proj4)
-          end
-        else
-          @proj4 = nil
-        end
-        @coord_sys = opts[:coord_sys]
-        if @coord_sys.is_a?(String)
-          @coord_sys = CoordSys::CS.create_from_wkt(@coord_sys)
-        end
-        if (!@proj4 || !@coord_sys) && @srid && (db = opts[:srs_database])
-          entry = db.get(@srid.to_i)
-          if entry
-            @proj4 ||= entry.proj4
-            @coord_sys ||= entry.coord_sys
-          end
-        end
-        @srid ||= @coord_sys.authority_code if @coord_sys
-        @srid = @srid.to_i
+        # Coordinate system (srid and coord_sys)
+        coord_sys_info = ImplHelper::Utils.setup_coord_sys(opts[:srid], opts[:coord_sys], opts[:coord_sys_class])
+        @srid = coord_sys_info[:srid]
+        @coord_sys = coord_sys_info[:coord_sys]
 
         # Interpret parser options
         wkt_parser = opts[:wkt_parser]
         case wkt_parser
-        when :geos
-          @wkt_reader = ::Geos::WktReader.new
-          @wkt_parser = nil
         when Hash
           @wkt_parser = WKRep::WKTParser.new(self, wkt_parser)
           @wkt_reader = nil
         else
-          @wkt_parser = WKRep::WKTParser.new(self)
-          @wkt_reader = nil
+          @wkt_reader = ::Geos::WktReader.new
+          @wkt_parser = nil
         end
         wkb_parser = opts[:wkb_parser]
         case wkb_parser
-        when :geos
-          @wkb_reader = ::Geos::WkbReader.new
-          @wkb_parser = nil
         when Hash
           @wkb_parser = WKRep::WKBParser.new(self, wkb_parser)
           @wkb_reader = nil
         else
-          @wkb_parser = WKRep::WKBParser.new(self)
-          @wkb_reader = nil
+          @wkb_reader = ::Geos::WkbReader.new
+          @wkb_parser = nil
         end
       end
 
@@ -118,19 +105,19 @@ 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) &&
-          @proj4.eql?(rhs.proj4)
+      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?
 
       # Standard hash code
 
       def hash
-        @hash ||= [@srid, @has_z, @has_m, @buffer_resolution, @proj4].hash
+        @hash ||= [@srid, @has_z, @has_m, @buffer_resolution, @coord_sys].hash
       end
 
       # Marshal support
@@ -141,42 +128,30 @@ module RGeo
           "hasm" => @has_m,
           "srid" => @srid,
           "bufr" => @buffer_resolution,
-          "wktg" => @wkt_generator.properties,
-          "wkbg" => @wkb_generator.properties,
-          "wktp" => @wkt_parser.properties,
-          "wkbp" => @wkb_parser.properties,
-          "lmpa" => @uses_lenient_multi_polygon_assertions,
+          "wktg" => @wkt_generator&.properties,
+          "wkbg" => @wkb_generator&.properties,
+          "wktp" => @wkt_parser&.properties,
+          "wkbp" => @wkb_parser&.properties,
           "apre" => @_auto_prepare
         }
-        hash["proj4"] = @proj4.marshal_dump if @proj4
         hash["cs"] = @coord_sys.to_wkt if @coord_sys
         hash
       end
 
       def marshal_load(data) # :nodoc:
-        if (proj4_data = data["proj4"]) && CoordSys.check!(:proj4)
-          proj4 = CoordSys::Proj4.allocate
-          proj4.marshal_load(proj4_data)
-        else
-          proj4 = nil
-        end
-        if (coord_sys_data = data["cs"])
-          coord_sys = CoordSys::CS.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"],
           srid: data["srid"],
           buffer_resolution: data["bufr"],
-          wkt_generator: symbolize_hash(data["wktg"]),
-          wkb_generator: symbolize_hash(data["wkbg"]),
-          wkt_parser: symbolize_hash(data["wktp"]),
-          wkb_parser: symbolize_hash(data["wkbp"]),
-          uses_lenient_multi_polygon_assertions: data["lmpa"],
+          wkt_generator: data["wktg"] && symbolize_hash(data["wktg"]),
+          wkb_generator: data["wkbg"] && symbolize_hash(data["wkbg"]),
+          wkt_parser: data["wktp"] && symbolize_hash(data["wktp"]),
+          wkb_parser: data["wkbp"] && symbolize_hash(data["wkbp"]),
           auto_prepare: (data["apre"] ? :simple : :disabled),
-          proj4: proj4,
           coord_sys: coord_sys
         )
       end
@@ -188,68 +163,33 @@ module RGeo
         coder["has_m_coordinate"] = @has_m
         coder["srid"] = @srid
         coder["buffer_resolution"] = @buffer_resolution
-        coder["lenient_multi_polygon_assertions"] = @uses_lenient_multi_polygon_assertions
-        coder["wkt_generator"] = @wkt_generator.properties
-        coder["wkb_generator"] = @wkb_generator.properties
-        coder["wkt_parser"] = @wkt_parser.properties
-        coder["wkb_parser"] = @wkb_parser.properties
+        coder["wkt_generator"] = @wkt_generator&.properties
+        coder["wkb_generator"] = @wkb_generator&.properties
+        coder["wkt_parser"] = @wkt_parser&.properties
+        coder["wkb_parser"] = @wkb_parser&.properties
         coder["auto_prepare"] = @_auto_prepare ? "simple" : "disabled"
-        if @proj4
-          str = @proj4.original_str || @proj4.canonical_str
-          coder["proj4"] = @proj4.radians? ? { "proj4" => str, "radians" => true } : str
-        end
         coder["coord_sys"] = @coord_sys.to_wkt if @coord_sys
       end
 
       def init_with(coder) # :nodoc:
-        if (proj4_data = coder["proj4"])
-          CoordSys.check!(:proj4)
-          if proj4_data.is_a?(Hash)
-            proj4 = CoordSys::Proj4.create(proj4_data["proj4"], radians: proj4_data["radians"])
-          else
-            proj4 = CoordSys::Proj4.create(proj4_data.to_s)
-          end
-        else
-          proj4 = nil
-        end
-        if (coord_sys_data = coder["cs"])
-          coord_sys = CoordSys::CS.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"],
           srid: coder["srid"],
           buffer_resolution: coder["buffer_resolution"],
-          wkt_generator: symbolize_hash(coder["wkt_generator"]),
-          wkb_generator: symbolize_hash(coder["wkb_generator"]),
-          wkt_parser: symbolize_hash(coder["wkt_parser"]),
-          wkb_parser: symbolize_hash(coder["wkb_parser"]),
+          wkt_generator: coder["wkt_generator"] && symbolize_hash(coder["wkt_generator"]),
+          wkb_generator: coder["wkb_generator"] && symbolize_hash(coder["wkb_generator"]),
+          wkt_parser: coder["wkt_parser"] && symbolize_hash(coder["wkt_parser"]),
+          wkb_parser: coder["wkb_parser"] && symbolize_hash(coder["wkb_parser"]),
           auto_prepare: coder["auto_prepare"] == "disabled" ? :disabled : :simple,
-          uses_lenient_multi_polygon_assertions: coder["lenient_multi_polygon_assertions"],
-          proj4: proj4,
           coord_sys: coord_sys
         )
       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
-
-      # Returns true if this factory is lenient with MultiPolygon assertions
-
-      def lenient_multi_polygon_assertions?
-        @uses_lenient_multi_polygon_assertions
-      end
-
       # See RGeo::Feature::Factory#property
-
       def property(name_)
         case name_
         when :has_z_coordinate
@@ -260,18 +200,19 @@ module RGeo
           true
         when :buffer_resolution
           @buffer_resolution
-        when :uses_lenient_multi_polygon_assertions
-          @uses_lenient_multi_polygon_assertions
         when :auto_prepare
           @_auto_prepare ? :simple : :disabled
         end
       end
 
       # See RGeo::Feature::Factory#parse_wkt
-
       def parse_wkt(str)
         if @wkt_reader
-          wrap_fg_geom(@wkt_reader.read(str), nil)
+          begin
+            wrap_fg_geom(@wkt_reader.read(str), nil)
+          rescue ::Geos::WktReader::ParseError => e
+            raise RGeo::Error::ParseError, e.message.partition(":").last
+          end
         else
           @wkt_parser.parse(str)
         end
@@ -281,7 +222,12 @@ module RGeo
 
       def parse_wkb(str)
         if @wkb_reader
-          wrap_fg_geom(@wkb_reader.read(str), nil)
+          begin
+            meth = str[0].match?(/[0-9a-fA-F]/) ? :read_hex : :read
+            wrap_fg_geom(@wkb_reader.public_send(meth, str), nil)
+          rescue ::Geos::WkbReader::ParseError => e
+            raise RGeo::Error::ParseError, e.message.partition(":").last
+          end
         else
           @wkb_parser.parse(str)
         end
@@ -351,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)
@@ -383,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
-        end
+          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)
@@ -417,33 +366,14 @@ module RGeo
           raise(RGeo::Error::InvalidGeometry, "Could not cast to polygon: #{elem}") unless elem
           elem.detach_fg_geom
         end
-        unless @uses_lenient_multi_polygon_assertions
-          (1...elems.size).each do |i|
-            (0...i).each do |j|
-              igeom = elems[i]
-              jgeom = elems[j]
-              if igeom.relate_pattern(jgeom, "2********") || igeom.relate_pattern(jgeom, "****1****")
-                raise(RGeo::Error::InvalidGeometry, "Invalid relate pattern: #{jgeom}")
-              end
-            end
-          end
-        end
         klasses = Array.new(elems.size, FFIPolygonImpl)
         fg_geom = ::Geos::Utils.create_collection(::Geos::GeomTypes::GEOS_MULTIPOLYGON, elems)
         FFIMultiPolygonImpl.new(self, fg_geom, klasses)
       end
 
-      # See RGeo::Feature::Factory#proj4
-
-      attr_reader :proj4
-
-      # 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
@@ -491,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)
@@ -520,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
@@ -534,6 +464,8 @@ 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)
         else
@@ -549,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