rgeo 3.0.0.pre.rc.1 → 3.0.0.pre.rc.3

data/ext/geos_c_impl/polygon.c

@@ -2,27 +2,24 @@
   Polygon methods for GEOS wrapper
 */
 
-
 #include "preface.h"
 
 #ifdef RGEO_GEOS_SUPPORTED
 
-#include <ruby.h>
 #include <geos_c.h>
+#include <ruby.h>
 
-#include "globals.h"
-
+#include "coordinates.h"
 #include "factory.h"
 #include "geometry.h"
+#include "globals.h"
 #include "line_string.h"
 #include "polygon.h"
 
-#include "coordinates.h"
-
 RGEO_BEGIN_C
 
-
-static VALUE method_polygon_eql(VALUE self, VALUE rhs)
+static VALUE
+method_polygon_eql(VALUE self, VALUE rhs)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
@@ -30,13 +27,14 @@ static VALUE method_polygon_eql(VALUE self, VALUE rhs)
   result = rgeo_geos_klasses_and_factories_eql(self, rhs);
   if (RTEST(result)) {
     self_data = RGEO_GEOMETRY_DATA_PTR(self);
-    result = rgeo_geos_geometries_strict_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom);
+    result = rgeo_geos_geometries_strict_eql(self_data->geom,
+                                             RGEO_GEOMETRY_DATA_PTR(rhs)->geom);
   }
   return result;
 }
 
-
-static VALUE method_polygon_hash(VALUE self)
+static VALUE
+method_polygon_hash(VALUE self)
 {
   st_index_t hash;
   RGeo_GeometryData* self_data;
@@ -46,12 +44,12 @@ static VALUE method_polygon_hash(VALUE self)
   factory = self_data->factory;
   hash = rb_hash_start(0);
   hash = rgeo_geos_objbase_hash(factory, rgeo_feature_polygon_module, hash);
-  hash = rgeo_geos_polygon_hash(self_data->geos_context, self_data->geom, hash);
+  hash = rgeo_geos_polygon_hash(self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
 
-
-static VALUE method_polygon_geometry_type(VALUE self)
+static VALUE
+method_polygon_geometry_type(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
@@ -64,8 +62,8 @@ static VALUE method_polygon_geometry_type(VALUE self)
   return result;
 }
 
-
-static VALUE method_polygon_area(VALUE self)
+static VALUE
+method_polygon_area(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
@@ -76,15 +74,15 @@ static VALUE method_polygon_area(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    if (GEOSArea_r(self_data->geos_context, self_geom, &area)) {
+    if (GEOSArea(self_geom, &area)) {
       result = rb_float_new(area);
     }
   }
   return result;
 }
 
-
-static VALUE method_polygon_centroid(VALUE self)
+static VALUE
+method_polygon_centroid(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
@@ -94,13 +92,14 @@ static VALUE method_polygon_centroid(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    result = rgeo_wrap_geos_geometry(self_data->factory, GEOSGetCentroid_r(self_data->geos_context, self_geom), rgeo_geos_point_class);
+    result = rgeo_wrap_geos_geometry(
+      self_data->factory, GEOSGetCentroid(self_geom), rgeo_geos_point_class);
   }
   return result;
 }
 
-
-static VALUE method_polygon_point_on_surface(VALUE self)
+static VALUE
+method_polygon_point_on_surface(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
@@ -110,18 +109,18 @@ static VALUE method_polygon_point_on_surface(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    result = rgeo_wrap_geos_geometry(self_data->factory, GEOSPointOnSurface_r(self_data->geos_context, self_geom), rgeo_geos_point_class);
+    result = rgeo_wrap_geos_geometry(
+      self_data->factory, GEOSPointOnSurface(self_geom), rgeo_geos_point_class);
   }
   return result;
 }
 
-
-static VALUE method_polygon_coordinates(VALUE self)
+static VALUE
+method_polygon_coordinates(VALUE self)
 {
   VALUE result = Qnil;
   RGeo_GeometryData* self_data;
   const GEOSGeometry* self_geom;
-  GEOSContextHandle_t self_context;
 
   int zCoordinate;
 
@@ -129,14 +128,15 @@ static VALUE method_polygon_coordinates(VALUE self)
   self_geom = self_data->geom;
 
   if (self_geom) {
-    zCoordinate = RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M;
-    self_context = self_data->geos_context;
-    result = extract_points_from_polygon(self_context, self_geom, zCoordinate);
+    zCoordinate = RGEO_FACTORY_DATA_PTR(self_data->factory)->flags &
+                  RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M;
+    result = extract_points_from_polygon(self_geom, zCoordinate);
   }
   return result;
 }
 
-static VALUE method_polygon_exterior_ring(VALUE self)
+static VALUE
+method_polygon_exterior_ring(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
@@ -146,13 +146,15 @@ static VALUE method_polygon_exterior_ring(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    result = rgeo_wrap_geos_geometry_clone(self_data->factory, GEOSGetExteriorRing_r(self_data->geos_context, self_geom), rgeo_geos_linear_ring_class);
+    result = rgeo_wrap_geos_geometry_clone(self_data->factory,
+                                           GEOSGetExteriorRing(self_geom),
+                                           rgeo_geos_linear_ring_class);
   }
   return result;
 }
 
-
-static VALUE method_polygon_num_interior_rings(VALUE self)
+static VALUE
+method_polygon_num_interior_rings(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
@@ -163,7 +165,7 @@ static VALUE method_polygon_num_interior_rings(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    num = GEOSGetNumInteriorRings_r(self_data->geos_context, self_geom);
+    num = GEOSGetNumInteriorRings(self_geom);
     if (num >= 0) {
       result = INT2NUM(num);
     }
@@ -171,150 +173,187 @@ static VALUE method_polygon_num_interior_rings(VALUE self)
   return result;
 }
 
-
-static VALUE method_polygon_interior_ring_n(VALUE self, VALUE n)
+static VALUE
+method_polygon_interior_ring_n(VALUE self, VALUE n)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
   const GEOSGeometry* self_geom;
   int i;
-  GEOSContextHandle_t self_context;
   int num;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    i = NUM2INT(n);
+    i = RB_NUM2INT(n);
     if (i >= 0) {
-      self_context = self_data->geos_context;
-      num = GEOSGetNumInteriorRings_r(self_context, self_geom);
+      num = GEOSGetNumInteriorRings(self_geom);
       if (i < num) {
-        result = rgeo_wrap_geos_geometry_clone(self_data->factory,
-          GEOSGetInteriorRingN_r(self_context, self_geom, i),
-          rgeo_geos_linear_ring_class);
+        result =
+          rgeo_wrap_geos_geometry_clone(self_data->factory,
+                                        GEOSGetInteriorRingN(self_geom, i),
+                                        rgeo_geos_linear_ring_class);
       }
     }
   }
   return result;
 }
 
-
-static VALUE method_polygon_interior_rings(VALUE self)
+static VALUE
+method_polygon_interior_rings(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
   const GEOSGeometry* self_geom;
-  GEOSContextHandle_t self_context;
   int count;
   VALUE factory;
-  VALUE linear_ring_class;
   int i;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    self_context = self_data->geos_context;
-    count = GEOSGetNumInteriorRings_r(self_context, self_geom);
+    count = GEOSGetNumInteriorRings(self_geom);
     if (count >= 0) {
       result = rb_ary_new2(count);
       factory = self_data->factory;
-      for (i=0; i<count; ++i) {
-        rb_ary_store(result, i, rgeo_wrap_geos_geometry_clone(factory, GEOSGetInteriorRingN_r(self_context, self_geom, i), rgeo_geos_linear_ring_class));
+      for (i = 0; i < count; ++i) {
+        rb_ary_store(
+          result,
+          i,
+          rgeo_wrap_geos_geometry_clone(factory,
+                                        GEOSGetInteriorRingN(self_geom, i),
+                                        rgeo_geos_linear_ring_class));
       }
     }
   }
   return result;
 }
 
-
-static VALUE cmethod_create(VALUE module, VALUE factory, VALUE exterior, VALUE interior_array)
+static VALUE
+cmethod_create(VALUE module,
+               VALUE factory,
+               VALUE exterior,
+               VALUE interior_array)
 {
   RGeo_FactoryData* factory_data;
   VALUE linear_ring_type;
   GEOSGeometry* exterior_geom;
-  GEOSContextHandle_t context;
   unsigned int len;
   GEOSGeometry** interior_geoms;
   unsigned int actual_len;
   unsigned int i;
   GEOSGeometry* interior_geom;
   GEOSGeometry* polygon;
+  int state = 0;
 
   Check_Type(interior_array, T_ARRAY);
   factory_data = RGEO_FACTORY_DATA_PTR(factory);
   linear_ring_type = rgeo_feature_linear_ring_module;
-  exterior_geom = rgeo_convert_to_detached_geos_geometry(exterior, factory, linear_ring_type, NULL);
-  if (exterior_geom) {
-    context = factory_data->geos_context;
-    len = (unsigned int)RARRAY_LEN(interior_array);
-    interior_geoms = ALLOC_N(GEOSGeometry*, len == 0 ? 1 : len);
-    if (interior_geoms) {
-      actual_len = 0;
-      for (i=0; i<len; ++i) {
-        interior_geom = rgeo_convert_to_detached_geos_geometry(rb_ary_entry(interior_array, i), factory, linear_ring_type, NULL);
-        if (interior_geom) {
-          interior_geoms[actual_len++] = interior_geom;
-        }
+  exterior_geom = rgeo_convert_to_detached_geos_geometry(
+    exterior, factory, linear_ring_type, NULL, &state);
+  if (state) {
+    rb_exc_raise(rb_errinfo());
+  }
+  if (!exterior_geom) {
+    return Qnil;
+  }
+
+  len = (unsigned int)RARRAY_LEN(interior_array);
+  interior_geoms = ALLOC_N(GEOSGeometry*, len == 0 ? 1 : len);
+  if (interior_geoms) {
+    actual_len = 0;
+    for (i = 0; i < len; ++i) {
+      interior_geom =
+        rgeo_convert_to_detached_geos_geometry(rb_ary_entry(interior_array, i),
+                                               factory,
+                                               linear_ring_type,
+                                               NULL,
+                                               &state);
+      if (interior_geom) {
+        interior_geoms[actual_len++] = interior_geom;
       }
-      if (len == actual_len) {
-        polygon = GEOSGeom_createPolygon_r(context, exterior_geom, interior_geoms, actual_len);
-        if (polygon) {
-          free(interior_geoms);
-          return rgeo_wrap_geos_geometry(factory, polygon, rgeo_geos_polygon_class);
-        }
+      if (state) {
+        break;
       }
-      for (i=0; i<actual_len; ++i) {
-        GEOSGeom_destroy_r(context, interior_geoms[i]);
+    }
+    if (len == actual_len) {
+      polygon =
+        GEOSGeom_createPolygon(exterior_geom, interior_geoms, actual_len);
+      if (polygon) {
+        FREE(interior_geoms);
+        // NOTE: we can return safely here, state cannot be other than 0.
+        return rgeo_wrap_geos_geometry(
+          factory, polygon, rgeo_geos_polygon_class);
       }
-      free(interior_geoms);
     }
-    GEOSGeom_destroy_r(context, exterior_geom);
+    for (i = 0; i < actual_len; ++i) {
+      GEOSGeom_destroy(interior_geoms[i]);
+    }
+    FREE(interior_geoms);
+  }
+  GEOSGeom_destroy(exterior_geom);
+  if (state) {
+    rb_exc_raise(rb_errinfo());
   }
   return Qnil;
 }
 
-
-void rgeo_init_geos_polygon()
+void
+rgeo_init_geos_polygon()
 {
   VALUE geos_polygon_methods;
 
   // Class methods for CAPIPolygonImpl
-  rb_define_module_function(rgeo_geos_polygon_class, "create", cmethod_create, 3);
+  rb_define_module_function(
+    rgeo_geos_polygon_class, "create", cmethod_create, 3);
 
   // CAPIPolygonMethods module
-  geos_polygon_methods = rb_define_module_under(rgeo_geos_module, "CAPIPolygonMethods");
+  geos_polygon_methods =
+    rb_define_module_under(rgeo_geos_module, "CAPIPolygonMethods");
   rb_define_method(geos_polygon_methods, "rep_equals?", method_polygon_eql, 1);
   rb_define_method(geos_polygon_methods, "eql?", method_polygon_eql, 1);
   rb_define_method(geos_polygon_methods, "hash", method_polygon_hash, 0);
-  rb_define_method(geos_polygon_methods, "geometry_type", method_polygon_geometry_type, 0);
+  rb_define_method(
+    geos_polygon_methods, "geometry_type", method_polygon_geometry_type, 0);
   rb_define_method(geos_polygon_methods, "area", method_polygon_area, 0);
-  rb_define_method(geos_polygon_methods, "centroid", method_polygon_centroid, 0);
-  rb_define_method(geos_polygon_methods, "point_on_surface", method_polygon_point_on_surface, 0);
-  rb_define_method(geos_polygon_methods, "exterior_ring", method_polygon_exterior_ring, 0);
-  rb_define_method(geos_polygon_methods, "num_interior_rings", method_polygon_num_interior_rings, 0);
-  rb_define_method(geos_polygon_methods, "interior_ring_n", method_polygon_interior_ring_n, 1);
-  rb_define_method(geos_polygon_methods, "interior_rings", method_polygon_interior_rings, 0);
-  rb_define_method(geos_polygon_methods, "coordinates", method_polygon_coordinates, 0);
+  rb_define_method(
+    geos_polygon_methods, "centroid", method_polygon_centroid, 0);
+  rb_define_method(geos_polygon_methods,
+                   "point_on_surface",
+                   method_polygon_point_on_surface,
+                   0);
+  rb_define_method(
+    geos_polygon_methods, "exterior_ring", method_polygon_exterior_ring, 0);
+  rb_define_method(geos_polygon_methods,
+                   "num_interior_rings",
+                   method_polygon_num_interior_rings,
+                   0);
+  rb_define_method(
+    geos_polygon_methods, "interior_ring_n", method_polygon_interior_ring_n, 1);
+  rb_define_method(
+    geos_polygon_methods, "interior_rings", method_polygon_interior_rings, 0);
+  rb_define_method(
+    geos_polygon_methods, "coordinates", method_polygon_coordinates, 0);
 }
 
-st_index_t rgeo_geos_polygon_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash)
+st_index_t
+rgeo_geos_polygon_hash(const GEOSGeometry* geom, st_index_t hash)
 {
   unsigned int len;
   unsigned int i;
 
   if (geom) {
-    hash = rgeo_geos_coordseq_hash(context, GEOSGetExteriorRing_r(context, geom), hash);
-    len = GEOSGetNumInteriorRings_r(context, geom);
-    for (i=0; i<len; ++i) {
-      hash = rgeo_geos_coordseq_hash(context, GEOSGetInteriorRingN_r(context, geom, i), hash);
+    hash = rgeo_geos_coordseq_hash(GEOSGetExteriorRing(geom), hash);
+    len = GEOSGetNumInteriorRings(geom);
+    for (i = 0; i < len; ++i) {
+      hash = rgeo_geos_coordseq_hash(GEOSGetInteriorRingN(geom, i), hash);
     }
   }
   return hash;
 }
 
-
 RGEO_END_C
 
 #endif

data/ext/geos_c_impl/polygon.h

@@ -2,21 +2,20 @@
   Polygon methods for GEOS wrapper
 */
 
-
 #ifndef RGEO_GEOS_POLYGON_INCLUDED
 #define RGEO_GEOS_POLYGON_INCLUDED
 
-#include <ruby.h>
 #include <geos_c.h>
+#include <ruby.h>
 
 RGEO_BEGIN_C
 
-
 /*
   Initializes the polygon module. This should be called after
   the geometry module is initialized.
 */
-void rgeo_init_geos_polygon();
+void
+rgeo_init_geos_polygon();
 
 /*
   Comopares the values of two GEOS polygons. The two given geometries MUST
@@ -24,17 +23,20 @@ void rgeo_init_geos_polygon();
   Returns Qtrue if the polygons are equal, Qfalse if they are inequal, or
   Qnil if an error occurs.
 */
-VALUE rgeo_geos_polygons_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z);
+VALUE
+rgeo_geos_polygons_eql(const GEOSGeometry* geom1,
+                       const GEOSGeometry* geom2,
+                       char check_z);
 
 /*
   A tool for building up hash values.
-  You must pass in the context, a geos geometry, and a seed hash.
+  You must pass in a geos geometry, and a seed hash.
   Returns an updated hash.
   This call is useful in sequence, and should be bracketed by calls to
   rb_hash_start and rb_hash_end.
 */
-st_index_t rgeo_geos_polygon_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash);
-
+st_index_t
+rgeo_geos_polygon_hash(const GEOSGeometry* geom, st_index_t hash);
 
 RGEO_END_C
 

data/ext/geos_c_impl/preface.h

@@ -2,7 +2,6 @@
   Preface header for GEOS wrapper
 */
 
-
 #ifdef HAVE_GEOS_C_H
 #ifdef HAVE_GEOSSETSRID_R
 #define RGEO_GEOS_SUPPORTED
@@ -24,24 +23,16 @@
 #ifdef HAVE_GEOSCOORDSEQ_ISCCW_R
 #define RGEO_GEOS_SUPPORTS_ISCCW
 #endif
-#ifdef HAVE_RB_MEMHASH
-#define RGEO_SUPPORTS_NEW_HASHING
-#endif
 #ifdef HAVE_RB_GC_MARK_MOVABLE
 #define mark rb_gc_mark_movable
 #else
 #define mark rb_gc_mark
 #endif
 
-#ifndef RGEO_SUPPORTS_NEW_HASHING
-#define st_index_t int
-#define rb_memhash(x,y) rgeo_internal_memhash(x,y)
-#define rb_hash_start(x) ((st_index_t)(x ^ 0xdeadbeef))
-#define rb_hash_end(x) ((st_index_t)(x ^ 0xbeefdead))
-#endif
-
 #ifdef __cplusplus
-#define RGEO_BEGIN_C extern "C" {
+#define RGEO_BEGIN_C                                                           \
+  extern "C"                                                                   \
+  {
 #define RGEO_END_C }
 #else
 #define RGEO_BEGIN_C
@@ -49,4 +40,8 @@
 #endif
 
 // https://ozlabs.org/~rusty/index.cgi/tech/2008-04-01.html
-#define streq(a, b) (!strcmp((a),(b)))
+#define streq(a, b) (!strcmp((a), (b)))
+
+// When using ruby ALLOC* macros, we are using ruby_xmalloc, which counterpart
+// is ruby_xfree. This macro helps enforcing that by showing us the way.
+#define FREE ruby_xfree

data/ext/geos_c_impl/ruby_more.c

@@ -0,0 +1,60 @@
+/*
+        Utilities for the ruby CAPI
+*/
+
+#ifndef RGEO_GEOS_RUBY_MORE_INCLUDED
+#define RGEO_GEOS_RUBY_MORE_INCLUDED
+
+#include "ruby_more.h"
+
+#include <ruby.h>
+
+#include "preface.h"
+
+RGEO_BEGIN_C
+
+struct funcall_args
+{
+  VALUE recv;
+  ID mid;
+  int argc;
+  VALUE* argv;
+};
+
+static VALUE
+inner_funcall(VALUE args_)
+{
+  struct funcall_args* args = (struct funcall_args*)args_;
+  return rb_funcallv(args->recv, args->mid, args->argc, args->argv);
+}
+
+VALUE
+rb_protect_funcall(VALUE recv, ID mid, int* state, int n, ...)
+{
+  struct funcall_args args;
+  VALUE* argv;
+  va_list ar;
+
+  if (n > 0) {
+    long i;
+    va_start(ar, n);
+    argv = ALLOCA_N(VALUE, n);
+    for (i = 0; i < n; i++) {
+      argv[i] = va_arg(ar, VALUE);
+    }
+    va_end(ar);
+  } else {
+    argv = 0;
+  }
+
+  args.recv = recv;
+  args.mid = mid;
+  args.argc = n;
+  args.argv = argv;
+
+  return rb_protect(inner_funcall, (VALUE)&args, state);
+}
+
+RGEO_END_C
+
+#endif

data/ext/geos_c_impl/ruby_more.h

@@ -0,0 +1,17 @@
+/*
+        Utilities for the ruby CAPI
+*/
+
+#ifndef RGEO_GEOS_RUBY_MORE_INCLUDED
+#define RGEO_GEOS_RUBY_MORE_INCLUDED
+
+#include <ruby.h>
+
+RGEO_BEGIN_C
+
+VALUE
+rb_protect_funcall(VALUE recv, ID mid, int* state, int n, ...);
+
+RGEO_END_C
+
+#endif

data/lib/rgeo/cartesian/bounding_box.rb

@@ -290,7 +290,7 @@ module RGeo
           false
         elsif @has_m && rhs.has_m && !opts[:ignore_m] && (@min_m > rhs.min_m || @max_m < rhs.max_m)
           false
-        elsif @has_z && rhs.has_z && !opts[:ignore_z] && (@min_z > rhs.min_z || @max_z < rhs.max_z)
+        elsif @has_z && rhs.has_z && !opts[:ignore_z] && (@min_z > rhs.min_z || @max_z < rhs.max_z) # rubocop:disable Style/IfWithBooleanLiteralBranches
           false
         else
           true