rgeo 2.3.1 → 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
@@ -41,24 +40,14 @@ module RGeo
       end
 
       def initialize(opts = {}) # :nodoc:
-        proj4 = opts[:proj4]
         coord_sys = opts[:coord_sys]
         srid = opts[:srid]
-        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
         config = {
-          uses_lenient_multi_polygon_assertions: opts[:lenient_multi_polygon_assertions] ||
-            opts[:uses_lenient_multi_polygon_assertions],
           buffer_resolution: opts[:buffer_resolution], auto_prepare: opts[:auto_prepare],
           wkt_generator: opts[:wkt_generator], wkt_parser: opts[:wkt_parser],
           wkb_generator: opts[:wkb_generator], wkb_parser: opts[:wkb_parser],
-          srid: srid.to_i, proj4: proj4, coord_sys: coord_sys
+          srid: srid.to_i, coord_sys: coord_sys
         }
         native_interface = opts[:native_interface] || Geos.preferred_native_interface
         if native_interface == :ffi
@@ -70,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
@@ -109,29 +102,18 @@ module RGeo
           "wkbg" => @wkb_generator.properties,
           "wktp" => @wkt_parser.properties,
           "wkbp" => @wkb_parser.properties,
-          "lmpa" => @zfactory.lenient_multi_polygon_assertions?,
           "apre" => @zfactory.property(:auto_prepare) == :simple,
           "nffi" => @zfactory.is_a?(FFIFactory)
         }
-        proj4 = @zfactory.proj4
         coord_sys = @zfactory.coord_sys
-        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(
           native_interface: (data["nffi"] ? :ffi : :capi),
           has_z_coordinate: data["hasz"],
@@ -142,9 +124,7 @@ module RGeo
           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"],
           auto_prepare: (data["apre"] ? :simple : :disabled),
-          proj4: proj4,
           coord_sys: coord_sys
         )
       end
@@ -154,38 +134,22 @@ module RGeo
       def encode_with(coder) # :nodoc:
         coder["srid"] = @zfactory.srid
         coder["buffer_resolution"] = @zfactory.buffer_resolution
-        coder["lenient_multi_polygon_assertions"] = @zfactory.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["auto_prepare"] = @zfactory.property(:auto_prepare).to_s
         coder["native_interface"] = @zfactory.is_a?(FFIFactory) ? "ffi" : "capi"
-        if (proj4 = @zfactory.proj4)
-          str = proj4.original_str || proj4.canonical_str
-          coder["proj4"] = proj4.radians? ? { "proj4" => str, "radians" => true } : str
-        end
-        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 (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(
           native_interface: coder["native_interface"] == "ffi" ? :ffi : :capi,
           has_z_coordinate: coder["has_z_coordinate"],
@@ -197,8 +161,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,
-          uses_lenient_multi_polygon_assertions: coder["lenient_multi_polygon_assertions"],
-          proj4: proj4,
           coord_sys: coord_sys
         )
       end
@@ -216,12 +178,6 @@ module RGeo
         @zfactory.buffer_resolution
       end
 
-      # Returns true if this factory is lenient with MultiPolygon assertions
-
-      def lenient_multi_polygon_assertions?
-        @zfactory.lenient_multi_polygon_assertions?
-      end
-
       # Returns the z-only factory corresponding to this factory.
 
       def z_factory
@@ -236,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?
 
@@ -271,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
@@ -295,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
@@ -322,12 +286,6 @@ module RGeo
         create_feature(ZMMultiPolygonImpl, @zfactory.multi_polygon(elems), @mfactory.multi_polygon(elems))
       end
 
-      # See RGeo::Feature::Factory#proj4
-
-      def proj4
-        @zfactory.proj4
-      end
-
       # See RGeo::Feature::Factory#coord_sys
 
       def coord_sys
@@ -347,7 +305,7 @@ module RGeo
           # Optimization if we're just changing factories, but to
           # another ZM factory.
           if original.factory != self && ntype == type &&
-              (!project || original.factory.proj4 == @proj4)
+              (!project || original.factory.coord_sys == @coord_sys)
             zresult = original.z_geometry.dup
             zresult.factory = @zfactory
             mresult = original.m_geometry.dup
@@ -356,7 +314,7 @@ module RGeo
           end
           # LineString conversion optimization.
           if (original.factory != self || ntype != type) &&
-              (!project || original.factory.proj4 == @proj4) &&
+              (!project || original.factory.coord_sys == @coord_sys) &&
               type.subtypeof?(Feature::LineString) && ntype.subtypeof?(Feature::LineString)
             klass = Factory::IMPL_CLASSES[ntype]
             zresult = klass._copy_from(@zfactory, original.z_geometry)

data/lib/rgeo/geos/zm_feature_methods.rb

@@ -26,7 +26,7 @@ module RGeo
       end
 
       def hash
-        @factory.hash ^ @zgeometry.hash ^ @mgeometry.hash
+        [@factory, @zgeometry, @mgeometry].hash
       end
 
       def factory
@@ -45,6 +45,14 @@ module RGeo
         @zgeometry.dimension
       end
 
+      def coordinate_dimension
+        4
+      end
+
+      def spatial_dimension
+        3
+      end
+
       def geometry_type
         @zgeometry.geometry_type
       end
@@ -69,18 +77,16 @@ module RGeo
         @zgeometry.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?
         @zgeometry.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?
+        true
+      end
+
+      def measured?
+        true
       end
 
       def boundary
@@ -122,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)
@@ -153,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?
@@ -236,26 +248,16 @@ module RGeo
         @zgeometry.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?
         @zgeometry.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 num_points
         @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
@@ -294,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
@@ -319,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
 
@@ -347,11 +349,6 @@ module RGeo
         @zgeometry.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 coordinates
         each.map(&:coordinates)
       end

data/lib/rgeo/geos.rb

@@ -33,9 +33,6 @@ module RGeo
       require_relative "geos/capi_feature_classes"
       require_relative "geos/capi_factory"
     end
-    require_relative "geos/ffi_feature_methods"
-    require_relative "geos/ffi_feature_classes"
-    require_relative "geos/ffi_factory"
     require_relative "geos/zm_feature_methods"
     require_relative "geos/zm_feature_classes"
     require_relative "geos/zm_factory"
@@ -48,12 +45,15 @@ module RGeo
       raise "Problem loading FFI" unless ::FFI::AutoPointer
       FFI_SUPPORTED = true
       FFI_SUPPORT_EXCEPTION = nil
-    rescue LoadError => ex
+    rescue LoadError, StandardError => e
       FFI_SUPPORTED = false
-      FFI_SUPPORT_EXCEPTION = ex
-    rescue StandardError => ex
-      FFI_SUPPORTED = false
-      FFI_SUPPORT_EXCEPTION = ex
+      FFI_SUPPORT_EXCEPTION = e
+    end
+
+    if FFI_SUPPORTED
+      require_relative "geos/ffi_feature_methods"
+      require_relative "geos/ffi_feature_classes"
+      require_relative "geos/ffi_factory"
     end
 
     # Default preferred native interface

data/lib/rgeo/impl_helper/basic_geometry_collection_methods.rb

@@ -20,19 +20,19 @@ module RGeo
           raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
           elem
         end
-        validate_geometry
+        init_geometry
       end
 
       def num_geometries
         @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)
@@ -55,11 +55,6 @@ module RGeo
         @elements.size == 0
       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 rep_equals?(rhs)
         if rhs.is_a?(self.class) && rhs.factory.eql?(@factory) && @elements.size == rhs.num_geometries
           rhs.each_with_index { |p, i| return false unless @elements[i].rep_equals?(p) }
@@ -69,10 +64,7 @@ module RGeo
       end
 
       def hash
-        @hash ||= begin
-          hash = [factory, geometry_type].hash
-          @elements.inject(hash) { |h, g| (1_664_525 * h + g.hash).hash }
-        end
+        @hash ||= [factory, geometry_type, *@elements].hash
       end
 
       private
@@ -91,7 +83,7 @@ module RGeo
           raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
           elem
         end
-        validate_geometry
+        init_geometry
       end
 
       def geometry_type
@@ -102,11 +94,6 @@ module RGeo
         all?(&: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 length
         @elements.inject(0.0) { |sum, obj| sum + obj.length }
       end
@@ -152,7 +139,7 @@ module RGeo
           raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
           elem
         end
-        validate_geometry
+        init_geometry
       end
 
       def geometry_type
@@ -176,7 +163,7 @@ module RGeo
           raise Error::InvalidGeometry, "Could not cast #{elem}" unless elem
           elem
         end
-        validate_geometry
+        init_geometry
       end
 
       def geometry_type

data/lib/rgeo/impl_helper/basic_geometry_methods.rb

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