rgeo 3.0.0 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc0fdafb5f2260dd8e4310275cdb5d07be71c7cdeb39c86d5aa6931a454df3cf
-  data.tar.gz: 1b47209e5205243eb568ed50eea430279c629a1c16cb290253de809dd3a99ee2
+  metadata.gz: 986cc6e02e2625161460dee926ef5237df6bd9959323190ab25fff10de68d76f
+  data.tar.gz: 10611b18bd565c006ff06bf12b152a07fed95968e46730fa652d39d2b4a6be5c
 SHA512:
-  metadata.gz: 40a807a8aa741e30715c5b7dc1a487ae9682c149ff3c94b7f370190fbf804c1f11ac034c0f697a923b49cef3f763121224c1e1cef6eafc5b9721a1ba0f6d4344
-  data.tar.gz: 72bec2c1432b56a2bb5ea50809f0d15d157c5c1e30379e756fb089c4dcd62a455d66783036e2d742c33ae552fe0f3a2ef40e53b07a26c6ccab21a2489f4f9214
+  metadata.gz: 85874f17611f284b7af91fce4bc383f5361f1880cdcb3cb2b40b4efd3c7c8146925cfac415819d4e1195dd92b9887fa0406fa3df786e7d651e5e55e165f231de
+  data.tar.gz: 7abe786c87c3138e94c665a2cd845d1f599e7238cdf505e25e68303ec1de575d5fd400393541d1c3e023fb57511f7ae8defeaceb60d4d08cecb013a04526035d

data/README.md

@@ -5,11 +5,10 @@
 
 RGeo is a geospatial data library for Ruby.
 
-:warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning:
+***Contributors Wanted!***
 
-This organization is looking for maintainers, see [this issue](https://github.com/rgeo/rgeo/issues/216) for more information.
+If you use RGeo and are interested in contributing, please check out our [open issues](https://github.com/rgeo/rgeo/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22%2C%22help+wanted%22) to see if there's anything you're able to help with.
 
-:warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning:
 
 ### Summary
 
@@ -37,7 +36,7 @@ Use the core **rgeo** gem to:
 
 RGeo works with the following Ruby implementations:
 
-*   MRI Ruby 2.6.0 or later.
+*   MRI Ruby 3.1.4 or later.
 *   Partial support for JRuby 9.0 or later. The FFI implementation of GEOS
     is available (ffi-geos gem required) but CAPI is not.
 *   See earlier versions for support for older ruby versions.

data/ext/geos_c_impl/extconf.rb

@@ -45,6 +45,8 @@ if have_header("geos_c.h")
   have_func("GEOSPreparedDisjoint_r", "geos_c.h")
   have_func("GEOSUnaryUnion_r", "geos_c.h")
   have_func("GEOSCoordSeq_isCCW_r", "geos_c.h")
+  have_func("GEOSDensify", "geos_c.h")
+  have_func("GEOSPolygonHullSimplify", "geos_c.h")
   have_func("rb_memhash", "ruby.h")
   have_func("rb_gc_mark_movable", "ruby.h")
 end

data/ext/geos_c_impl/factory.c

@@ -378,6 +378,7 @@ method_factory_write_for_marshal(VALUE self, VALUE obj)
   wkb_writer = self_data->marshal_wkb_writer;
   if (!wkb_writer) {
     wkb_writer = GEOSWKBWriter_create();
+    GEOSWKBWriter_setOutputDimension(wkb_writer, 2);
     if (has_3d) {
       GEOSWKBWriter_setOutputDimension(wkb_writer, 3);
     }
@@ -427,6 +428,7 @@ method_factory_write_for_psych(VALUE self, VALUE obj)
   wkt_writer = self_data->psych_wkt_writer;
   if (!wkt_writer) {
     wkt_writer = GEOSWKTWriter_create();
+    GEOSWKTWriter_setOutputDimension(wkt_writer, 2);
     GEOSWKTWriter_setTrim(wkt_writer, 1);
     if (has_3d) {
       GEOSWKTWriter_setOutputDimension(wkt_writer, 3);
@@ -1008,7 +1010,7 @@ rgeo_geos_coordseqs_eql(const GEOSGeometry* geom1,
               result = Qnil;
               break;
             }
-          }      // Iteration over coords
+          } // Iteration over coords
         } else { // Lengths are different
           result = Qfalse;
         }

data/ext/geos_c_impl/factory.h

@@ -105,8 +105,8 @@ extern const rb_data_type_t rgeo_geometry_type;
   (_RGEO_TYPEDDATA_P(object, &rgeo_geometry_type))
 
 #define _RGEO_TYPEDDATA_P(object, data_type)                                   \
-  (TYPE(object) == T_DATA && RTYPEDDATA(object)->typed_flag == 1 &&            \
-   RTYPEDDATA(object)->type == data_type)
+  (RB_TYPE_P(object, T_DATA) && RTYPEDDATA_P(object) &&                        \
+   RTYPEDDATA_TYPE(object) == data_type)
 
 // Returns the RGeo_FactoryData* given a ruby Factory object
 #define RGEO_FACTORY_DATA_PTR(factory)                                         \

data/ext/geos_c_impl/geometry.c

@@ -266,6 +266,7 @@ method_geometry_as_text(VALUE self)
       wkt_writer = factory_data->wkt_writer;
       if (!wkt_writer) {
         wkt_writer = GEOSWKTWriter_create();
+        GEOSWKTWriter_setOutputDimension(wkt_writer, 2);
         GEOSWKTWriter_setTrim(wkt_writer, 1);
         factory_data->wkt_writer = wkt_writer;
       }
@@ -304,6 +305,7 @@ method_geometry_as_binary(VALUE self)
 
       if (!wkb_writer) {
         wkb_writer = GEOSWKBWriter_create();
+        GEOSWKBWriter_setOutputDimension(wkb_writer, 2);
         factory_data->wkb_writer = wkb_writer;
       }
       str = (char*)GEOSWKBWriter_write(wkb_writer, self_geom, &size);
@@ -738,6 +740,27 @@ method_geometry_buffer(VALUE self, VALUE distance)
   return result;
 }
 
+#ifdef RGEO_GEOS_SUPPORTS_DENSIFY
+static VALUE
+method_geometry_segmentize(VALUE self, VALUE max_segment_length)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  VALUE factory;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (self_geom) {
+    factory = self_data->factory;
+    result = rgeo_wrap_geos_geometry(
+      factory, GEOSDensify(self_geom, rb_num2dbl(max_segment_length)), Qnil);
+  }
+  return result;
+}
+#endif
+
 static VALUE
 method_geometry_buffer_with_style(VALUE self,
                                   VALUE distance,
@@ -1306,6 +1329,10 @@ rgeo_init_geos_geometry()
     geos_geometry_methods, "make_valid", method_geometry_make_valid, 0);
   rb_define_method(
     geos_geometry_methods, "polygonize", method_geometry_polygonize, 0);
+#ifdef RGEO_GEOS_SUPPORTS_DENSIFY
+  rb_define_method(
+    geos_geometry_methods, "segmentize", method_geometry_segmentize, 1);
+#endif
 }
 
 RGEO_END_C

data/ext/geos_c_impl/globals.c

@@ -56,8 +56,7 @@ notice_handler(const char* fmt, ...)
 #endif
 }
 
-static void
-error_handler(const char* fmt, ...)
+NORETURN(static void error_handler(const char* fmt, ...))
 {
   // See https://en.cppreference.com/w/c/io/vfprintf
   va_list args1;

data/ext/geos_c_impl/point.c

@@ -212,7 +212,8 @@ rgeo_create_geos_point(VALUE factory, double x, double y, double z)
   GEOSGeometry* geom;
 
   result = Qnil;
-  coord_seq = GEOSCoordSeq_create(1, 3);
+  coord_seq = GEOSCoordSeq_create(
+    1, 3); // Never cleaned if failure setting one of the coord
   if (coord_seq) {
     if (GEOSCoordSeq_setX(coord_seq, 0, x)) {
       if (GEOSCoordSeq_setY(coord_seq, 0, y)) {

data/ext/geos_c_impl/polygon.c

@@ -231,6 +231,34 @@ method_polygon_interior_rings(VALUE self)
   return result;
 }
 
+#ifdef RGEO_GEOS_SUPPORTS_POLYGON_HULL_SIMPLIFY
+static VALUE
+method_polygon_simplify_polygon_hull(VALUE self,
+                                     VALUE vertex_fraction,
+                                     VALUE is_outer)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  VALUE factory;
+
+  unsigned int is_outer_uint = RTEST(is_outer) ? 1 : 0;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (self_geom) {
+    factory = self_data->factory;
+    result = rgeo_wrap_geos_geometry(
+      factory,
+      GEOSPolygonHullSimplify(
+        self_geom, is_outer_uint, rb_num2dbl(vertex_fraction)),
+      Qnil);
+  }
+  return result;
+}
+#endif
+
 static VALUE
 cmethod_create(VALUE module,
                VALUE factory,
@@ -335,6 +363,13 @@ rgeo_init_geos_polygon()
     geos_polygon_methods, "interior_rings", method_polygon_interior_rings, 0);
   rb_define_method(
     geos_polygon_methods, "coordinates", method_polygon_coordinates, 0);
+
+#ifdef RGEO_GEOS_SUPPORTS_POLYGON_HULL_SIMPLIFY
+  rb_define_method(geos_polygon_methods,
+                   "simplify_polygon_hull",
+                   method_polygon_simplify_polygon_hull,
+                   2);
+#endif
 }
 
 st_index_t

data/ext/geos_c_impl/preface.h

@@ -23,6 +23,12 @@
 #ifdef HAVE_GEOSCOORDSEQ_ISCCW_R
 #define RGEO_GEOS_SUPPORTS_ISCCW
 #endif
+#ifdef HAVE_GEOSDENSIFY
+#define RGEO_GEOS_SUPPORTS_DENSIFY
+#endif
+#ifdef HAVE_GEOSPOLYGONHULLSIMPLIFY
+#define RGEO_GEOS_SUPPORTS_POLYGON_HULL_SIMPLIFY
+#endif
 #ifdef HAVE_RB_GC_MARK_MOVABLE
 #define mark rb_gc_mark_movable
 #else

data/lib/rgeo/cartesian/factory.rb

@@ -121,7 +121,7 @@ module RGeo
           wkt_parser: symbolize_hash(data["wktp"]),
           wkb_parser: symbolize_hash(data["wkbp"]),
           buffer_resolution: data["bufr"],
-          coord_sys: coord_sys
+          coord_sys:
         )
       end
 
@@ -152,7 +152,7 @@ module RGeo
           wkt_parser: symbolize_hash(coder["wkt_parser"]),
           wkb_parser: symbolize_hash(coder["wkb_parser"]),
           buffer_resolution: coder["buffer_resolution"],
-          coord_sys: coord_sys
+          coord_sys:
         )
       end
 

data/lib/rgeo/coord_sys/cs/entities.rb

@@ -251,6 +251,7 @@ module RGeo
         # :startdoc:
 
         def initialize(name, orientation) # :nodoc:
+          super()
           @name = name
           @orientation =
             case orientation
@@ -302,6 +303,7 @@ module RGeo
       # system that the projected coordinate system is based on.
       class ProjectionParameter < Base
         def initialize(name, value) # :nodoc:
+          super()
           @name = name
           @value = value.to_f
         end
@@ -339,6 +341,7 @@ module RGeo
       # points East, and the Z axis points North.
       class WGS84ConversionInfo < Base
         def initialize(dx_meters, dy_meters, dz_meters, ex_arc_seconds, ey_arc_seconds, ez_arc_seconds, ppm) # :nodoc:
+          super()
           @dx = dx_meters.to_f
           @dy = dy_meters.to_f
           @dz = dz_meters.to_f
@@ -427,6 +430,7 @@ module RGeo
       class Info < Base
         def initialize(name, authority = nil, authority_code = nil, abbreviation = nil, init_alias = nil,
                        remarks = nil, extensions = nil) # :nodoc:
+          super()
           @name = name
           @authority = authority ? authority.to_s : nil
           @authority_code = authority_code ? authority_code.to_s : nil
@@ -817,8 +821,8 @@ module RGeo
         private
 
         def wkt_content(standard_brackets)
-          array = [@ellipsoid.to_wkt(standard_brackets: standard_brackets)]
-          array << @wgs84_parameters.to_wkt(standard_brackets: standard_brackets) if @wgs84_parameters
+          array = [@ellipsoid.to_wkt(standard_brackets:)]
+          array << @wgs84_parameters.to_wkt(standard_brackets:) if @wgs84_parameters
           array
         end
       end
@@ -851,8 +855,8 @@ module RGeo
 
         # Iterates over the parameters of the projection.
 
-        def each_parameter(&block)
-          @parameters.each(&block)
+        def each_parameter(&)
+          @parameters.each(&)
         end
 
         def wkt_typename
@@ -1024,7 +1028,7 @@ module RGeo
         private
 
         def wkt_content(standard_brackets)
-          [@head.to_wkt(standard_brackets: standard_brackets), @tail.to_wkt(standard_brackets: standard_brackets)]
+          [@head.to_wkt(standard_brackets:), @tail.to_wkt(standard_brackets:)]
         end
       end
 
@@ -1088,9 +1092,9 @@ module RGeo
 
         def wkt_content(standard_brackets)
           [
-            @local_datum.to_wkt(standard_brackets: standard_brackets),
-            @unit.to_wkt(standard_brackets: standard_brackets)
-          ] + @axes.map { |ax| ax.to_wkt(standard_brackets: standard_brackets) }
+            @local_datum.to_wkt(standard_brackets:),
+            @unit.to_wkt(standard_brackets:)
+          ] + @axes.map { |ax| ax.to_wkt(standard_brackets:) }
         end
       end
 
@@ -1161,13 +1165,13 @@ module RGeo
 
         def wkt_content(standard_brackets)
           arr = [
-            @horizontal_datum.to_wkt(standard_brackets: standard_brackets),
-            @prime_meridian.to_wkt(standard_brackets: standard_brackets),
-            @linear_unit.to_wkt(standard_brackets: standard_brackets)
+            @horizontal_datum.to_wkt(standard_brackets:),
+            @prime_meridian.to_wkt(standard_brackets:),
+            @linear_unit.to_wkt(standard_brackets:)
           ]
-          arr << @axis0.to_wkt(standard_brackets: standard_brackets) if @axis0
-          arr << @axis1.to_wkt(standard_brackets: standard_brackets) if @axis1
-          arr << @axis2.to_wkt(standard_brackets: standard_brackets) if @axis2
+          arr << @axis0.to_wkt(standard_brackets:) if @axis0
+          arr << @axis1.to_wkt(standard_brackets:) if @axis1
+          arr << @axis2.to_wkt(standard_brackets:) if @axis2
           arr
         end
       end
@@ -1222,10 +1226,10 @@ module RGeo
 
         def wkt_content(standard_brackets)
           arr = [
-            @vertical_datum.to_wkt(standard_brackets: standard_brackets),
-            @vertical_unit.to_wkt(standard_brackets: standard_brackets)
+            @vertical_datum.to_wkt(standard_brackets:),
+            @vertical_unit.to_wkt(standard_brackets:)
           ]
-          arr << @axis.to_wkt(standard_brackets: standard_brackets) if @axis
+          arr << @axis.to_wkt(standard_brackets:) if @axis
           arr
         end
       end
@@ -1324,12 +1328,12 @@ module RGeo
 
         def wkt_content(standard_brackets)
           arr = [
-            @horizontal_datum.to_wkt(standard_brackets: standard_brackets),
-            @prime_meridian.to_wkt(standard_brackets: standard_brackets),
-            @angular_unit.to_wkt(standard_brackets: standard_brackets)
+            @horizontal_datum.to_wkt(standard_brackets:),
+            @prime_meridian.to_wkt(standard_brackets:),
+            @angular_unit.to_wkt(standard_brackets:)
           ]
-          arr << @axis0.to_wkt(standard_brackets: standard_brackets) if @axis0
-          arr << @axis1.to_wkt(standard_brackets: standard_brackets) if @axis1
+          arr << @axis0.to_wkt(standard_brackets:) if @axis0
+          arr << @axis1.to_wkt(standard_brackets:) if @axis1
           arr
         end
       end
@@ -1393,13 +1397,13 @@ module RGeo
 
         def wkt_content(standard_brackets)
           arr = [
-            @geographic_coordinate_system.to_wkt(standard_brackets: standard_brackets),
-            @projection.to_wkt(standard_brackets: standard_brackets)
+            @geographic_coordinate_system.to_wkt(standard_brackets:),
+            @projection.to_wkt(standard_brackets:)
           ]
-          @projection.each_parameter { |param| arr << param.to_wkt(standard_brackets: standard_brackets) }
-          arr << @linear_unit.to_wkt(standard_brackets: standard_brackets)
-          arr << @axis0.to_wkt(standard_brackets: standard_brackets) if @axis0
-          arr << @axis1.to_wkt(standard_brackets: standard_brackets) if @axis1
+          @projection.each_parameter { |param| arr << param.to_wkt(standard_brackets:) }
+          arr << @linear_unit.to_wkt(standard_brackets:)
+          arr << @axis0.to_wkt(standard_brackets:) if @axis0
+          arr << @axis1.to_wkt(standard_brackets:) if @axis1
           arr
         end
       end
@@ -1546,8 +1550,8 @@ module RGeo
         private
 
         def wkt_content(standard_brackets)
-          source_cs_wkt = "SOURCECS[#{source_cs.to_wkt(standard_brackets: standard_brackets)}]"
-          target_cs_wkt = "TARGETCS[#{target_cs.to_wkt(standard_brackets: standard_brackets)}]"
+          source_cs_wkt = "SOURCECS[#{source_cs.to_wkt(standard_brackets:)}]"
+          target_cs_wkt = "TARGETCS[#{target_cs.to_wkt(standard_brackets:)}]"
 
           [source_cs_wkt, target_cs_wkt]
         end

data/lib/rgeo/feature/geometry_collection.rb

@@ -94,7 +94,7 @@ module RGeo
       # Note that all GeometryCollection implementations must also
       # include the Enumerable mixin.
 
-      def each(&_block)
+      def each(&)
         raise Error::UnsupportedOperation, "Method #{self.class}#each not defined."
       end
 

data/lib/rgeo/feature/types.rb

@@ -78,8 +78,8 @@ module RGeo
 
       # Iterates over the known immediate subtypes of this type.
 
-      def each_immediate_subtype(&block)
-        @subtypes&.each(&block)
+      def each_immediate_subtype(&)
+        @subtypes&.each(&)
       end
 
       # Returns the OpenGIS type name of this type. For example:
@@ -191,21 +191,15 @@ module RGeo
           if nfactory == factory
             force_new ? obj.dup : obj
           elsif type == Point
-            cs = ncs = nil
-            if project
-              cs = factory.coord_sys
-              ncs = nfactory.coord_sys
-            end
-            hasz = factory.property(:has_z_coordinate)
-            nhasz = nfactory.property(:has_z_coordinate)
-            if cs && ncs
-              coords = cs.transform_coords(ncs, obj.x, obj.y, hasz ? obj.z : nil)
-              coords << (hasz ? obj.z : 0.0) if nhasz && coords.size < 3
-            else
-              coords = [obj.x, obj.y]
-              coords << (hasz ? obj.z : 0.0) if nhasz
-            end
-            coords << (factory.property(:has_m_coordinate) ? obj.m : 0.0) if nfactory.property(:has_m_coordinate)
+            z = factory.property(:has_z_coordinate) ? obj.z : nil
+            coords = if project && (cs = factory.coord_sys) && (ncs = nfactory.coord_sys)
+                       cs.transform_coords(ncs, obj.x, obj.y, z)
+                     else
+                       [obj.x, obj.y]
+                     end
+            coords << (z || 0.0) if nfactory.property(:has_z_coordinate) && coords.size < 3
+            m = factory.property(:has_m_coordinate) ? obj.m : nil
+            coords << (m || 0.0) if nfactory.property(:has_m_coordinate)
             nfactory.point(*coords)
           elsif type == Line
             nfactory.line(cast(obj.start_point, nfactory, opts), cast(obj.end_point, nfactory, opts))

data/lib/rgeo/geographic/factory.rb

@@ -139,7 +139,7 @@ module RGeo
           wkt_parser: symbolize_hash(data_["wktp"]),
           wkb_parser: symbolize_hash(data_["wkbp"]),
           buffer_resolution: data_["bufr"],
-          coord_sys: coord_sys
+          coord_sys:
         )
         proj_klass = data_["prjc"]
         proj_factory = data_["prjf"]
@@ -189,7 +189,7 @@ module RGeo
           wkt_parser: symbolize_hash(coder["wkt_parser"]),
           wkb_parser: symbolize_hash(coder["wkb_parser"]),
           buffer_resolution: coder["buffer_resolution"],
-          coord_sys: coord_sys
+          coord_sys:
         )
         proj_klass = coder["projectorclass"]
         proj_factory = coder["projection_factory"]

data/lib/rgeo/geographic/interface.rb

@@ -106,7 +106,7 @@ module RGeo
           "Spherical",
           has_z_coordinate: opts[:has_z_coordinate],
           has_m_coordinate: opts[:has_m_coordinate],
-          coord_sys: coord_sys || coord_sys_4055,
+          coord_sys: coord_sys || coord_sys4055,
           buffer_resolution: opts[:buffer_resolution],
           wkt_parser: opts[:wkt_parser],
           wkb_parser: opts[:wkb_parser],
@@ -189,7 +189,7 @@ module RGeo
       def simple_mercator_factory(opts = {})
         factory = Geographic::Factory.new(
           "Projected",
-          coord_sys: coord_sys_4326,
+          coord_sys: coord_sys4326,
           srid: 4326,
           wkt_parser: opts[:wkt_parser],
           wkb_parser: opts[:wkb_parser],
@@ -323,7 +323,7 @@ module RGeo
           # Now we should have all the coordinate system info.
           factory = Geographic::Factory.new(
             "Projected",
-            coord_sys: coord_sys,
+            coord_sys:,
             srid: srid.to_i,
             has_z_coordinate: projection_factory.property(:has_z_coordinate),
             has_m_coordinate: projection_factory.property(:has_m_coordinate),
@@ -355,7 +355,7 @@ module RGeo
           # Now we should have all the coordinate system info.
           factory = Geographic::Factory.new(
             "Projected",
-            coord_sys: coord_sys,
+            coord_sys:,
             srid: srid.to_i,
             has_z_coordinate: opts[:has_z_coordinate],
             has_m_coordinate: opts[:has_m_coordinate],
@@ -379,16 +379,16 @@ module RGeo
 
       private
 
-      def coord_sys_4055
-        return @coord_sys_4055 if defined?(@coord_sys_4055)
+      def coord_sys4055
+        return @coord_sys4055 if defined?(@coord_sys4055)
 
-        @coord_sys_4055 = CoordSys::CONFIG.default_coord_sys_class.create(4055)
+        @coord_sys4055 = CoordSys::CONFIG.default_coord_sys_class.create(4055)
       end
 
-      def coord_sys_4326
-        return @coord_sys_4326 if defined?(@coord_sys_4326)
+      def coord_sys4326
+        return @coord_sys4326 if defined?(@coord_sys4326)
 
-        @coord_sys_4326 = CoordSys::CONFIG.default_coord_sys_class.create(4326)
+        @coord_sys4326 = CoordSys::CONFIG.default_coord_sys_class.create(4326)
       end
     end
   end

data/lib/rgeo/geographic/projected_window.rb

@@ -66,7 +66,7 @@ module RGeo
       def eql?(other) # :nodoc:
         return false unless other.is_a?(ProjectedWindow)
         @factory == other.factory && @x_min == other.x_min && @x_max == other.x_max &&
-          @y_min = other.y_min && @y_max = other.y_max
+          @y_min == other.y_min && @y_max == other.y_max
       end
       alias == eql?
 

data/lib/rgeo/geographic/simple_mercator_projector.rb

@@ -14,7 +14,7 @@ module RGeo
       def initialize(geography_factory, opts = {})
         @geography_factory = geography_factory
         @projection_factory = Cartesian.preferred_factory(srid: 3857,
-                                                          coord_sys: SimpleMercatorProjector._coordsys_3857,
+                                                          coord_sys: SimpleMercatorProjector._coordsys3857,
                                                           buffer_resolution: opts[:buffer_resolution],
                                                           has_z_coordinate: opts[:has_z_coordinate],
                                                           has_m_coordinate: opts[:has_m_coordinate])
@@ -104,10 +104,10 @@ module RGeo
         )
       end
 
-      def self._coordsys_3857 # :nodoc:
-        return @coordsys_3857 if defined?(@coordsys_3857)
+      def self._coordsys3857 # :nodoc:
+        return @coordsys3857 if defined?(@coordsys3857)
 
-        @coordsys_3857 = CoordSys::CONFIG.default_coord_sys_class.create(3857)
+        @coordsys3857 = CoordSys::CONFIG.default_coord_sys_class.create(3857)
       end
     end
   end

data/lib/rgeo/geos/ffi_factory.rb

@@ -56,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
@@ -66,6 +67,7 @@ module RGeo
           @wkb_writer = nil
         else
           @wkb_writer = ::Geos::WkbWriter.new
+          @wkb_writer.output_dimensions = 2
           @wkb_generator = nil
         end
 
@@ -150,7 +152,7 @@ module RGeo
           wkt_parser: data["wktp"] && symbolize_hash(data["wktp"]),
           wkb_parser: data["wkbp"] && symbolize_hash(data["wkbp"]),
           auto_prepare: (data["apre"] ? :simple : :disabled),
-          coord_sys: coord_sys
+          coord_sys:
         )
       end
 
@@ -183,7 +185,7 @@ module RGeo
           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,
-          coord_sys: coord_sys
+          coord_sys:
         )
       end
 
@@ -295,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)
@@ -327,16 +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(
+          RGeo::Feature.cast(
             elem,
             self,
             RGeo::Feature::Point,
             :force_new,
             :keep_subtype
           )
-          return unless elem
-          elem.detach_fg_geom
         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)
@@ -449,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
@@ -463,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)
@@ -485,8 +487,8 @@ module RGeo
           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

@@ -168,43 +168,43 @@ module RGeo
 
       def disjoint?(rhs)
         fg = factory.convert_to_fg_geometry(rhs)
-        prep = request_prepared if Utils.ffi_supports_prepared_level_2
+        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)
-        prep = request_prepared if Utils.ffi_supports_prepared_level_1
+        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)
-        prep = request_prepared if Utils.ffi_supports_prepared_level_2
+        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)
-        prep = request_prepared if Utils.ffi_supports_prepared_level_2
+        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)
-        prep = request_prepared if Utils.ffi_supports_prepared_level_2
+        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)
-        prep = request_prepared if Utils.ffi_supports_prepared_level_1
+        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)
-        prep = request_prepared if Utils.ffi_supports_prepared_level_2
+        prep = request_prepared if Utils.ffi_supports_prepared_level2
         prep ? prep.overlaps?(fg) : @fg_geom.overlaps?(fg)
       end
 
@@ -212,7 +212,6 @@ module RGeo
         fg = factory.convert_to_fg_geometry(rhs)
         @fg_geom.relate_pattern(fg, pattern)
       end
-      alias relate relate? # DEPRECATED
 
       def distance(rhs)
         fg = factory.convert_to_fg_geometry(rhs)

data/lib/rgeo/geos/utils.rb

@@ -55,11 +55,11 @@ module RGeo
           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
 

data/lib/rgeo/geos/zm_factory.rb

@@ -47,7 +47,7 @@ module RGeo
           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, coord_sys: coord_sys
+          srid: srid.to_i, coord_sys:
         }
         native_interface = opts[:native_interface] || Geos.preferred_native_interface
         if native_interface == :ffi
@@ -125,7 +125,7 @@ module RGeo
           wkt_parser: symbolize_hash(data["wktp"]),
           wkb_parser: symbolize_hash(data["wkbp"]),
           auto_prepare: (data["apre"] ? :simple : :disabled),
-          coord_sys: coord_sys
+          coord_sys:
         )
       end
 
@@ -161,7 +161,7 @@ module RGeo
           wkt_parser: symbolize_hash(coder["wkt_parser"]),
           wkb_parser: symbolize_hash(coder["wkb_parser"]),
           auto_prepare: coder["auto_prepare"] == "disabled" ? :disabled : :simple,
-          coord_sys: coord_sys
+          coord_sys:
         )
       end
 

data/lib/rgeo/geos/zm_feature_methods.rb

@@ -128,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)

data/lib/rgeo/geos.rb

@@ -26,7 +26,13 @@ module RGeo
     begin
       require_relative "geos/geos_c_impl"
     rescue LoadError
-      # continue
+      # fall back to a system-wide search if the c-extension is stored in different location
+      # important for systems such as Amazon Linux
+      begin
+        require "geos/geos_c_impl"
+      rescue LoadError
+        # continue
+      end
     end
     CAPI_SUPPORTED = RGeo::Geos.const_defined?(:CAPIGeometryMethods)
     if CAPI_SUPPORTED

data/lib/rgeo/impl_helper/basic_geometry_collection_methods.rb

@@ -35,8 +35,8 @@ module RGeo
         @elements[idx]
       end
 
-      def each(&block)
-        @elements.each(&block)
+      def each(&)
+        @elements.each(&)
       end
 
       def geometries

data/lib/rgeo/impl_helper/utils.rb

@@ -27,7 +27,7 @@ module RGeo
         # Create a coord sys based on the SRID if one was not given
         coord_sys = coord_sys_class.create(srid) if coord_sys.nil? && srid != 0
 
-        { coord_sys: coord_sys, srid: srid }
+        { coord_sys:, srid: }
       end
 
       private

data/lib/rgeo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RGeo
-  VERSION = "3.0.0"
+  VERSION = "3.1.0"
 end

metadata

@@ -1,15 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rgeo
 version: !ruby/object:Gem::Version
-  version: 3.0.0
+  version: 3.1.0
 platform: ruby
 authors:
 - Daniel Azuma
 - Tee Parham
-autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-01-25 00:00:00.000000000 Z
+date: 2026-01-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi-geos
@@ -39,6 +38,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '5.11'
+- !ruby/object:Gem::Dependency
+  name: ostruct
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -87,14 +100,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '3.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.0'
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -229,8 +242,8 @@ homepage: https://github.com/rgeo/rgeo
 licenses:
 - BSD-3-Clause
 metadata:
+  funding_uri: https://opencollective.com/rgeo
   rubygems_mfa_required: 'true'
-post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
@@ -238,15 +251,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.6.0
+      version: 3.1.4
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.6.4
 specification_version: 4
 summary: RGeo is a geospatial data library for Ruby.
 test_files: []