rgeo 3.0.0.pre.rc.3 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91ca209240d93482556f0aaf2b1dcb3beca7710af47a3cba6b12014a09a8b3be
-  data.tar.gz: b22b62247f1c4f3d07d4e7e4c1552999ae42d1d0d94808cc2fa7805e48914acd
+  metadata.gz: dc0fdafb5f2260dd8e4310275cdb5d07be71c7cdeb39c86d5aa6931a454df3cf
+  data.tar.gz: 1b47209e5205243eb568ed50eea430279c629a1c16cb290253de809dd3a99ee2
 SHA512:
-  metadata.gz: 803a18e2ccb670da3db22c630bda86bb6ad80643c8a3e4e6bae448a1e3003632904bdf90b2d7642601857c01b92ffbf4a5e354fd292fb85033db7c0e19cd49b3
-  data.tar.gz: 142ada28031864f3a2960605b504aa3daf222db98d190fc208589b31841f328cefb5192391594a6237b48d1aab907eae2250e63c12824ef65d22f6ca01546057
+  metadata.gz: 40a807a8aa741e30715c5b7dc1a487ae9682c149ff3c94b7f370190fbf804c1f11ac034c0f697a923b49cef3f763121224c1e1cef6eafc5b9721a1ba0f6d4344
+  data.tar.gz: 72bec2c1432b56a2bb5ea50809f0d15d157c5c1e30379e756fb089c4dcd62a455d66783036e2d742c33ae552fe0f3a2ef40e53b07a26c6ccab21a2489f4f9214

data/README.md

@@ -74,6 +74,14 @@ If you are using proj.4 extensions, include
 gem "rgeo-proj4"
 ```
 
+### Upgrading to Version 3.0
+
+See [doc/Upgrading-to-v3.md](doc/Upgrading-to-v3.md) for a checklist of changes to make before upgrading to RGeo 3.0.
+
+For a brief overview of the changes, see [NEWS.md](NEWS.md).
+
+For a comprehensive list of all changes, see [History.md](History.md).
+
 
 ### Extensions
 
@@ -130,6 +138,7 @@ Here's the current list of available topics:
 - [Factory Compatibility](https://github.com/rgeo/rgeo/blob/main/doc/Factory-Compatibility.md)
 - [Which factory should I use?](https://github.com/rgeo/rgeo/blob/main/doc/Which-factory-should-I-use.md)
 - [Geometry validity handling](https://github.com/rgeo/rgeo/blob/main/doc/Geometry-Validity.md)
+- [Upgrading to Version 3](https://github.com/rgeo/rgeo/blob/main/doc/Upgrading-to-v3.md)
 - [Examples](https://github.com/rgeo/rgeo/blob/main/doc/Examples.md)
 - [Who uses `rgeo`?](https://github.com/rgeo/rgeo/blob/main/doc/Gallery.md)
 

data/ext/geos_c_impl/factory.c

@@ -820,7 +820,7 @@ rgeo_wrap_geos_geometry_clone(VALUE factory,
 }
 
 const GEOSGeometry*
-rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALUE type)
+rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALUE type, int* state)
 {
   VALUE object;
 
@@ -831,10 +831,28 @@ rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALUE type)
     object =
       rb_funcall(rgeo_feature_module, rb_intern("cast"), 3, obj, factory, type);
   }
-  if (NIL_P(object))
+  if (NIL_P(object)) {
+    rb_protect(
+      rb_exc_raise_value,
+      rb_exc_new_cstr(rb_eRGeoInvalidGeometry,
+                      "Unable to cast the geometry to the GEOS Factory"),
+      state);
+  }
+
+  if (*state) {
+    return NULL;
+  }
+
+  if (!rgeo_is_geos_object(object)) {
+    rb_protect(rb_exc_raise_value,
+               rb_exc_new_cstr(rb_eRGeoError, "Not a GEOS Geometry object."),
+               state);
+  }
+
+  if (*state) {
     return NULL;
+  }
 
-  Check_TypedStruct(object, &rgeo_geometry_type);
   return RGEO_GEOMETRY_DATA_PTR(object)->geom;
 }
 
@@ -849,6 +867,7 @@ rgeo_convert_to_detached_geos_geometry(VALUE obj,
   GEOSGeometry* geom;
   RGeo_GeometryData* object_data;
   const GEOSPreparedGeometry* prep;
+
   if (klasses) {
     *klasses = Qnil;
   }
@@ -862,7 +881,24 @@ rgeo_convert_to_detached_geos_geometry(VALUE obj,
                               type,
                               ID2SYM(rb_intern("force_new")),
                               ID2SYM(rb_intern("keep_subtype")));
-  if (*state || NIL_P(object)) {
+
+  if (NIL_P(object)) {
+    rb_protect(
+      rb_exc_raise_value,
+      rb_exc_new_cstr(rb_eRGeoInvalidGeometry,
+                      "Unable to cast the geometry to the GEOS Factory"),
+      state);
+  }
+  if (*state) {
+    return NULL;
+  }
+
+  if (!rgeo_is_geos_object(object)) {
+    rb_protect(rb_exc_raise_value,
+               rb_exc_new_cstr(rb_eRGeoError, "Not a GEOS Geometry object."),
+               state);
+  }
+  if (*state) {
     return NULL;
   }
 
@@ -1023,7 +1059,7 @@ rgeo_geos_coordseq_hash(const GEOSGeometry* geom, st_index_t hash)
         for (i = 0; i < len; ++i) {
           if (GEOSCoordSeq_getX(cs, i, &hash_struct.x)) {
             if (GEOSCoordSeq_getY(cs, i, &hash_struct.y)) {
-              if (!GEOSCoordSeq_getY(cs, i, &hash_struct.z)) {
+              if (!GEOSCoordSeq_getZ(cs, i, &hash_struct.z)) {
                 hash_struct.z = 0;
               }
               hash_struct.seed_hash = hash;

data/ext/geos_c_impl/factory.h

@@ -154,9 +154,18 @@ rgeo_wrap_geos_geometry_clone(VALUE factory,
   specified by an appropriate feature module. Passing Qnil for the type
   disables this auto-cast. The returned GEOS geometry is owned by rgeo,
   and you should not dispose it or take ownership of it yourself.
+
+  The state parameter is given to follow `rb_protect*` ruby methods: this
+  method calls `#cast`, and this call may raise. if it does raise, state
+  will be set to a non-zero value, and you'll have access to the error
+  in `rb_errinfo()`. IT IS THE CALLER'S RESPONSIBILITY TO PROPAGATE THE
+  ERROR. You could also discard the error with `rb_set_errinfo(Qnil)`,
+  this will just ignore the error altogether. The error can be raised
+  with `rb_jump_tag(state)` which is helpful if you need to free data
+  before you raise the error.
 */
 const GEOSGeometry*
-rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALUE type);
+rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALUE type, int* state);
 
 /*
   Gets a GEOS geometry for a given ruby Geometry object. You must provide
@@ -179,7 +188,9 @@ rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALUE type);
   will be set to a non-zero value, and you'll have access to the error
   in `rb_errinfo()`. IT IS THE CALLER'S RESPONSIBILITY TO PROPAGATE THE
   ERROR. You could also discard the error with `rb_set_errinfo(Qnil)`,
-  this will just ignore the error altogether.
+  this will just ignore the error altogether. The error can be raised
+  with `rb_jump_tag(state)` which is helpful if you need to free data
+  before you raise the error.
 */
 GEOSGeometry*
 rgeo_convert_to_detached_geos_geometry(VALUE obj,

data/ext/geos_c_impl/geometry.c

@@ -367,7 +367,6 @@ method_geometry_equals(VALUE self, VALUE rhs)
   RGeo_GeometryData* self_data;
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
-  char val;
 
   // Shortcut when self and rhs are the same object.
   if (self == rhs) {
@@ -385,12 +384,7 @@ method_geometry_equals(VALUE self, VALUE rhs)
       if (GEOSisEmpty(self_geom) == 1 && GEOSisEmpty(rhs_geom) == 1) {
         result = Qtrue;
       } else {
-        val = GEOSEquals(self_geom, rhs_geom);
-        if (val == 0) {
-          result = Qfalse;
-        } else if (val == 1) {
-          result = Qtrue;
-        }
+        result = GEOSEquals(self_geom, rhs_geom) ? Qtrue : Qfalse;
       }
     }
   }
@@ -411,7 +405,7 @@ method_geometry_disjoint(VALUE self, VALUE rhs)
   RGeo_GeometryData* self_data;
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
-  char val;
+  int state = 0;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
   const GEOSPreparedGeometry* prep;
 #endif
@@ -420,21 +414,18 @@ method_geometry_disjoint(VALUE self, VALUE rhs)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
-      prep = rgeo_request_prepared_geometry(self_data);
-      if (prep)
-        val = GEOSPreparedDisjoint(prep, rhs_geom);
-      else
+    prep = rgeo_request_prepared_geometry(self_data);
+    if (prep)
+      result = GEOSPreparedDisjoint(prep, rhs_geom) ? Qtrue : Qfalse;
+    else
 #endif
-        val = GEOSDisjoint(self_geom, rhs_geom);
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
-    }
+      result = GEOSDisjoint(self_geom, rhs_geom) ? Qtrue : Qfalse;
   }
   return result;
 }
@@ -447,6 +438,7 @@ method_geometry_intersects(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   char val;
+  int state = 0;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED1
   const GEOSPreparedGeometry* prep;
 #endif
@@ -455,20 +447,22 @@ method_geometry_intersects(VALUE self, VALUE rhs)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED1
-      prep = rgeo_request_prepared_geometry(self_data);
-      if (prep)
-        val = GEOSPreparedIntersects(prep, rhs_geom);
-      else
+    prep = rgeo_request_prepared_geometry(self_data);
+    if (prep)
+      val = GEOSPreparedIntersects(prep, rhs_geom);
+    else
 #endif
-        val = GEOSIntersects(self_geom, rhs_geom);
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
+      val = GEOSIntersects(self_geom, rhs_geom);
+    if (val == 0) {
+      result = Qfalse;
+    } else if (val == 1) {
+      result = Qtrue;
     }
   }
   return result;
@@ -482,6 +476,7 @@ method_geometry_touches(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   char val;
+  int state = 0;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
   const GEOSPreparedGeometry* prep;
 #endif
@@ -490,20 +485,22 @@ method_geometry_touches(VALUE self, VALUE rhs)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
-      prep = rgeo_request_prepared_geometry(self_data);
-      if (prep)
-        val = GEOSPreparedTouches(prep, rhs_geom);
-      else
+    prep = rgeo_request_prepared_geometry(self_data);
+    if (prep)
+      val = GEOSPreparedTouches(prep, rhs_geom);
+    else
 #endif
-        val = GEOSTouches(self_geom, rhs_geom);
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
+      val = GEOSTouches(self_geom, rhs_geom);
+    if (val == 0) {
+      result = Qfalse;
+    } else if (val == 1) {
+      result = Qtrue;
     }
   }
   return result;
@@ -517,6 +514,7 @@ method_geometry_crosses(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   char val;
+  int state = 0;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
   const GEOSPreparedGeometry* prep;
 #endif
@@ -525,20 +523,22 @@ method_geometry_crosses(VALUE self, VALUE rhs)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
-      prep = rgeo_request_prepared_geometry(self_data);
-      if (prep)
-        val = GEOSPreparedCrosses(prep, rhs_geom);
-      else
+    prep = rgeo_request_prepared_geometry(self_data);
+    if (prep)
+      val = GEOSPreparedCrosses(prep, rhs_geom);
+    else
 #endif
-        val = GEOSCrosses(self_geom, rhs_geom);
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
+      val = GEOSCrosses(self_geom, rhs_geom);
+    if (val == 0) {
+      result = Qfalse;
+    } else if (val == 1) {
+      result = Qtrue;
     }
   }
   return result;
@@ -552,6 +552,7 @@ method_geometry_within(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   char val;
+  int state = 0;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
   const GEOSPreparedGeometry* prep;
 #endif
@@ -560,20 +561,22 @@ method_geometry_within(VALUE self, VALUE rhs)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
-      prep = rgeo_request_prepared_geometry(self_data);
-      if (prep)
-        val = GEOSPreparedWithin(prep, rhs_geom);
-      else
+    prep = rgeo_request_prepared_geometry(self_data);
+    if (prep)
+      val = GEOSPreparedWithin(prep, rhs_geom);
+    else
 #endif
-        val = GEOSWithin(self_geom, rhs_geom);
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
+      val = GEOSWithin(self_geom, rhs_geom);
+    if (val == 0) {
+      result = Qfalse;
+    } else if (val == 1) {
+      result = Qtrue;
     }
   }
   return result;
@@ -587,6 +590,7 @@ method_geometry_contains(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   char val;
+  int state = 0;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED1
   const GEOSPreparedGeometry* prep;
 #endif
@@ -595,20 +599,22 @@ method_geometry_contains(VALUE self, VALUE rhs)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED1
-      prep = rgeo_request_prepared_geometry(self_data);
-      if (prep)
-        val = GEOSPreparedContains(prep, rhs_geom);
-      else
+    prep = rgeo_request_prepared_geometry(self_data);
+    if (prep)
+      val = GEOSPreparedContains(prep, rhs_geom);
+    else
 #endif
-        val = GEOSContains(self_geom, rhs_geom);
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
+      val = GEOSContains(self_geom, rhs_geom);
+    if (val == 0) {
+      result = Qfalse;
+    } else if (val == 1) {
+      result = Qtrue;
     }
   }
   return result;
@@ -622,6 +628,7 @@ method_geometry_overlaps(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   char val;
+  int state = 0;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
   const GEOSPreparedGeometry* prep;
 #endif
@@ -630,20 +637,22 @@ method_geometry_overlaps(VALUE self, VALUE rhs)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
-      prep = rgeo_request_prepared_geometry(self_data);
-      if (prep)
-        val = GEOSPreparedOverlaps(prep, rhs_geom);
-      else
+    prep = rgeo_request_prepared_geometry(self_data);
+    if (prep)
+      val = GEOSPreparedOverlaps(prep, rhs_geom);
+    else
 #endif
-        val = GEOSOverlaps(self_geom, rhs_geom);
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
+      val = GEOSOverlaps(self_geom, rhs_geom);
+    if (val == 0) {
+      result = Qfalse;
+    } else if (val == 1) {
+      result = Qtrue;
     }
   }
   return result;
@@ -657,19 +666,23 @@ method_geometry_relate(VALUE self, VALUE rhs, VALUE pattern)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   char val;
+  int state = 0;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
-      val = GEOSRelatePattern(self_geom, rhs_geom, StringValuePtr(pattern));
-      if (val == 0) {
-        result = Qfalse;
-      } else if (val == 1) {
-        result = Qtrue;
-      }
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
+
+    val = GEOSRelatePattern(self_geom, rhs_geom, StringValuePtr(pattern));
+    if (val == 0) {
+      result = Qfalse;
+    } else if (val == 1) {
+      result = Qtrue;
     }
   }
   return result;
@@ -683,16 +696,20 @@ method_geometry_distance(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   const GEOSGeometry* rhs_geom;
   double dist;
+  int state = 0;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
-    if (rhs_geom) {
-      if (GEOSDistance(self_geom, rhs_geom, &dist)) {
-        result = rb_float_new(dist);
-      }
+    rhs_geom =
+      rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
+    }
+
+    if (GEOSDistance(self_geom, rhs_geom, &dist)) {
+      result = rb_float_new(dist);
     }
   }
   return result;
@@ -816,17 +833,20 @@ method_geometry_intersection(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   VALUE factory;
   const GEOSGeometry* rhs_geom;
+  int state = 0;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
     factory = self_data->factory;
-    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
-    if (rhs_geom) {
-      result = rgeo_wrap_geos_geometry(
-        factory, GEOSIntersection(self_geom, rhs_geom), Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
     }
+
+    result = rgeo_wrap_geos_geometry(
+      factory, GEOSIntersection(self_geom, rhs_geom), Qnil);
   }
   return result;
 }
@@ -839,17 +859,20 @@ method_geometry_union(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   VALUE factory;
   const GEOSGeometry* rhs_geom;
+  int state = 0;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
     factory = self_data->factory;
-    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
-    if (rhs_geom) {
-      result =
-        rgeo_wrap_geos_geometry(factory, GEOSUnion(self_geom, rhs_geom), Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
     }
+
+    result =
+      rgeo_wrap_geos_geometry(factory, GEOSUnion(self_geom, rhs_geom), Qnil);
   }
   return result;
 }
@@ -880,17 +903,20 @@ method_geometry_difference(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   VALUE factory;
   const GEOSGeometry* rhs_geom;
+  int state = 0;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
     factory = self_data->factory;
-    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
-    if (rhs_geom) {
-      result = rgeo_wrap_geos_geometry(
-        factory, GEOSDifference(self_geom, rhs_geom), Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
     }
+
+    result = rgeo_wrap_geos_geometry(
+      factory, GEOSDifference(self_geom, rhs_geom), Qnil);
   }
   return result;
 }
@@ -903,17 +929,20 @@ method_geometry_sym_difference(VALUE self, VALUE rhs)
   const GEOSGeometry* self_geom;
   VALUE factory;
   const GEOSGeometry* rhs_geom;
+  int state = 0;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
     factory = self_data->factory;
-    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
-    if (rhs_geom) {
-      result = rgeo_wrap_geos_geometry(
-        factory, GEOSSymDifference(self_geom, rhs_geom), Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil, &state);
+    if (state) {
+      rb_jump_tag(state);
     }
+
+    result = rgeo_wrap_geos_geometry(
+      factory, GEOSSymDifference(self_geom, rhs_geom), Qnil);
   }
   return result;
 }

data/ext/geos_c_impl/geometry_collection.c

@@ -31,7 +31,6 @@ create_geometry_collection(VALUE module, int type, VALUE factory, VALUE array)
   VALUE result;
   unsigned int len;
   GEOSGeometry** geoms;
-  RGeo_FactoryData* factory_data;
   VALUE klass;
   unsigned int i;
   unsigned int j;
@@ -49,7 +48,6 @@ create_geometry_collection(VALUE module, int type, VALUE factory, VALUE array)
     rb_raise(rb_eRGeoError, "not enough memory available");
   }
 
-  factory_data = RGEO_FACTORY_DATA_PTR(factory);
   klasses = Qnil;
   cast_type = Qnil;
   switch (type) {
@@ -66,9 +64,14 @@ create_geometry_collection(VALUE module, int type, VALUE factory, VALUE array)
   for (i = 0; i < len; ++i) {
     geom = rgeo_convert_to_detached_geos_geometry(
       rb_ary_entry(array, i), factory, cast_type, &klass, &state);
-    if (state || !geom) {
-      break;
+    if (state) {
+      for (j = 0; j < i; j++) {
+        GEOSGeom_destroy(geoms[j]);
+      }
+      FREE(geoms);
+      rb_jump_tag(state);
     }
+
     geoms[i] = geom;
     if (!NIL_P(klass) && NIL_P(klasses)) {
       klasses = rb_ary_new2(len);
@@ -80,24 +83,19 @@ create_geometry_collection(VALUE module, int type, VALUE factory, VALUE array)
       rb_ary_push(klasses, klass);
     }
   }
-  if (i != len) {
-    for (j = 0; j < i; ++j) {
-      GEOSGeom_destroy(geoms[j]);
-    }
-  } else {
-    collection = GEOSGeom_createCollection(type, geoms, len);
-    if (collection) {
-      result = rgeo_wrap_geos_geometry(factory, collection, module);
-      RGEO_GEOMETRY_DATA_PTR(result)->klasses = klasses;
-    }
-    // NOTE: We are assuming that GEOS will do its own cleanup of the
-    // element geometries if it fails to create the collection, so we
-    // are not doing that ourselves. If that turns out not to be the
-    // case, this will be a memory leak.
+  collection = GEOSGeom_createCollection(type, geoms, len);
+  if (collection) {
+    result = rgeo_wrap_geos_geometry(factory, collection, module);
+    RGEO_GEOMETRY_DATA_PTR(result)->klasses = klasses;
   }
+
+  // NOTE: We are assuming that GEOS will do its own cleanup of the
+  // element geometries if it fails to create the collection, so we
+  // are not doing that ourselves. If that turns out not to be the
+  // case, this will be a memory leak.
   FREE(geoms);
   if (state) {
-    rb_exc_raise(rb_errinfo()); // raise $!
+    rb_jump_tag(state);
   }
 
   return result;