rgeo 3.0.0.pre.rc.2 → 3.0.0.pre.rc.3

data/lib/rgeo/geos/capi_factory.rb

@@ -20,83 +20,64 @@ module RGeo
         #
         # See RGeo::Geos.factory for a list of supported options.
 
-        def create(opts_ = {})
+        def create(opts = {})
           # Make sure GEOS is available
           return unless respond_to?(:_create)
 
           # Get flags to pass to the C extension
           flags = 0
-          flags |= 2 if opts_[:has_z_coordinate]
-          flags |= 4 if opts_[:has_m_coordinate]
+          flags |= 2 if opts[:has_z_coordinate]
+          flags |= 4 if opts[:has_m_coordinate]
           if flags & 6 == 6
             raise Error::UnsupportedOperation, "GEOS cannot support both Z and M coordinates at the same time."
           end
-          flags |= 8 unless opts_[:auto_prepare] == :disabled
+          flags |= 8 unless opts[:auto_prepare] == :disabled
 
           # Buffer resolution
-          buffer_resolution_ = opts_[:buffer_resolution].to_i
-          buffer_resolution_ = 1 if buffer_resolution_ < 1
+          buffer_resolution = opts[:buffer_resolution].to_i
+          buffer_resolution = 1 if buffer_resolution < 1
 
           # Interpret the generator options
-          wkt_generator_ = opts_[:wkt_generator]
-          case wkt_generator_
-          when :geos
-            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)
           else
-            wkt_generator_ = WKRep::WKTGenerator.new(convert_case: :upper)
+            wkt_generator = nil
           end
-          wkb_generator_ = opts_[:wkb_generator]
-          case wkb_generator_
-          when :geos
-            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)
           else
-            wkb_generator_ = WKRep::WKBGenerator.new
+            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
-          srid_ ||= coord_sys_.authority_code if coord_sys_
+          # 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]
 
           # Create the factory and set instance variables
-          result = _create(flags, srid_.to_i, buffer_resolution_,
-            wkt_generator_, wkb_generator_, proj4_, coord_sys_)
+          result = _create(flags, srid.to_i, buffer_resolution,
+            wkt_generator, wkb_generator, coord_sys)
 
           # Interpret parser options
-          wkt_parser_ = opts_[:wkt_parser]
-          case wkt_parser_
-          when :geos
-            wkt_parser_ = nil
+          wkt_parser = opts[:wkt_parser]
+          case wkt_parser
           when Hash
-            wkt_parser_ = WKRep::WKTParser.new(result, wkt_parser_)
+            wkt_parser = WKRep::WKTParser.new(result, wkt_parser)
           else
-            wkt_parser_ = WKRep::WKTParser.new(result)
+            wkt_parser = nil
           end
-          wkb_parser_ = opts_[:wkb_parser]
-          case wkb_parser_
-          when :geos
-            wkb_parser_ = nil
+          wkb_parser = opts[:wkb_parser]
+          case wkb_parser
           when Hash
-            wkb_parser_ = WKRep::WKBParser.new(result, wkb_parser_)
+            wkb_parser = WKRep::WKBParser.new(result, wkb_parser)
           else
-            wkb_parser_ = WKRep::WKBParser.new(result)
+            wkb_parser = nil
           end
-          result._set_wkrep_parsers(wkt_parser_, wkb_parser_)
+          result._set_wkrep_parsers(wkt_parser, wkb_parser)
 
           # Return the result
           result
@@ -115,14 +96,14 @@ module RGeo
       def eql?(rhs_)
         rhs_.is_a?(CAPIFactory) && rhs_.srid == _srid &&
           rhs_._buffer_resolution == _buffer_resolution && rhs_._flags == _flags &&
-          rhs_.proj4 == _proj4
+          rhs_.coord_sys == coord_sys
       end
       alias == eql?
 
       # Standard hash code
 
       def hash
-        @hash ||= [_srid, _buffer_resolution, _flags, _proj4].hash
+        @hash ||= [_srid, _buffer_resolution, _flags].hash
       end
 
       # Marshal support
@@ -139,9 +120,6 @@ module RGeo
           "wkbp" => _wkb_parser ? _wkb_parser.properties : {},
           "apre" => auto_prepare
         }
-        if (proj4_ = _proj4)
-          hash_["proj4"] = proj4_.marshal_dump
-        end
         if (coord_sys_ = _coord_sys)
           hash_["cs"] = coord_sys_.to_wkt
         end
@@ -149,14 +127,8 @@ module RGeo
       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_)
+          coord_sys_ = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data_)
         else
           coord_sys_ = nil
         end
@@ -171,7 +143,6 @@ module RGeo
             wkt_parser: symbolize_hash(data_["wktp"]),
             wkb_parser: symbolize_hash(data_["wkbp"]),
             auto_prepare: data_["apre"],
-            proj4: proj4_,
             coord_sys: coord_sys_
           )
         )
@@ -189,28 +160,14 @@ module RGeo
         coder_["wkt_parser"] = _wkt_parser ? _wkt_parser.properties : {}
         coder_["wkb_parser"] = _wkb_parser ? _wkb_parser.properties : {}
         coder_["auto_prepare"] = auto_prepare
-        if (proj4_ = _proj4)
-          str_ = proj4_.original_str || proj4_.canonical_str
-          coder_["proj4"] = proj4_.radians? ? { "proj4" => str_, "radians" => true } : str_
-        end
         if (coord_sys_ = _coord_sys)
           coder_["coord_sys"] = coord_sys_.to_wkt
         end
       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)
+          coord_sys_ = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data_.to_s)
         else
           coord_sys_ = nil
         end
@@ -225,7 +182,6 @@ module RGeo
             wkt_parser: symbolize_hash(coder_["wkt_parser"]),
             wkb_parser: symbolize_hash(coder_["wkb_parser"]),
             auto_prepare: coder_["auto_prepare"] == "disabled" ? :disabled : :simple,
-            proj4: proj4_,
             coord_sys: coord_sys_
           )
         )
@@ -276,11 +232,7 @@ module RGeo
         if (wkb_parser_ = _wkb_parser)
           wkb_parser_.parse(str_)
         else
-          if str_[0] == "\x00" || str_[0] == "\x01"
-            _parse_wkb_impl(str_)
-          else
-            _parse_wkb_impl([str_].pack('H*'))
-          end
+          _parse_wkb_impl(str_)
         end
       end
 
@@ -351,12 +303,6 @@ module RGeo
           raise(RGeo::Error::InvalidGeometry, "Parse error")
       end
 
-      # See RGeo::Feature::Factory#proj4
-
-      def proj4
-        _proj4
-      end
-
       # See RGeo::Feature::Factory#coord_sys
 
       def coord_sys
@@ -375,10 +321,10 @@ module RGeo
         case original
         when CAPIGeometryMethods
           # Optimization if we're just changing factories, but the
-          # factories are zm-compatible and proj4-compatible.
+          # factories are zm-compatible and coord_sys-compatible.
           if original.factory != self && ntype == type &&
               original.factory._flags & FLAG_SUPPORTS_Z_OR_M == _flags & FLAG_SUPPORTS_Z_OR_M &&
-              (!project || original.factory.proj4 == _proj4)
+              (!project || original.factory.coord_sys == coord_sys)
             result = original.dup
             result.factory = self
             return result
@@ -386,7 +332,7 @@ module RGeo
           # LineString conversion optimization.
           if (original.factory != self || ntype != type) &&
               original.factory._flags & FLAG_SUPPORTS_Z_OR_M == _flags & FLAG_SUPPORTS_Z_OR_M &&
-              (!project || original.factory.proj4 == _proj4) &&
+              (!project || original.factory.coord_sys == coord_sys) &&
               type.subtype_of?(Feature::LineString) && ntype.subtype_of?(Feature::LineString)
             return IMPL_CLASSES[ntype]._copy_from(self, original)
           end

data/lib/rgeo/geos/capi_feature_classes.rb

@@ -24,16 +24,6 @@ module RGeo
         factory.supports_z? ? 3 : 2
       end
 
-      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?
-      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?
-      end
-
       def is_3d?
         factory.supports_z?
       end
@@ -81,25 +71,6 @@ 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

data/lib/rgeo/geos/ffi_factory.rb

@@ -33,75 +33,52 @@ module RGeo
         @_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.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_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
-        @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
       attr_reader :coordinate_dimension, :spatial_dimension
@@ -119,14 +96,14 @@ module RGeo
           @has_z == rhs.property(:has_z_coordinate) &&
           @has_m == rhs.property(:has_m_coordinate) &&
           @buffer_resolution == rhs.property(:buffer_resolution) &&
-          @proj4.eql?(rhs.proj4)
+          @coord_sys.eql?(rhs.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
@@ -137,26 +114,19 @@ 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,
+          "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)
+          coord_sys = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data)
         else
           coord_sys = nil
         end
@@ -165,12 +135,11 @@ module RGeo
           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"]),
+          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
@@ -182,31 +151,17 @@ module RGeo
         coder["has_m_coordinate"] = @has_m
         coder["srid"] = @srid
         coder["buffer_resolution"] = @buffer_resolution
-        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)
+          coord_sys = CoordSys::CONFIG.default_coord_sys_class.create_from_wkt(coord_sys_data.to_s)
         else
           coord_sys = nil
         end
@@ -215,12 +170,11 @@ module RGeo
           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,
-          proj4: proj4,
           coord_sys: coord_sys
         )
       end
@@ -253,7 +207,11 @@ module RGeo
       # 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
@@ -263,7 +221,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
@@ -404,10 +367,6 @@ module RGeo
         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
@@ -505,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.trim = true
           wkt_writer.output_dimensions = 3 if @_has_3d
           wkt_writer.write(geom.fg_geom)
         else

data/lib/rgeo/geos/ffi_feature_methods.rb

@@ -125,20 +125,10 @@ 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?
-      end
-
       def is_3d?
         factory.property(:has_z_coordinate)
       end
@@ -415,20 +405,10 @@ 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) &&
           Utils.ffi_coord_seqs_equal?(rhs.fg_geom.coord_seq, @fg_geom.coord_seq, @factory._has_3d)
@@ -565,12 +545,7 @@ module RGeo
       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
@@ -615,11 +590,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,11 +57,6 @@ 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.
 
@@ -127,14 +112,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.
+      #   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>]