rgeo 2.3.1 → 3.0.0.pre.rc.2

data/ext/geos_c_impl/line_string.c

@@ -11,6 +11,8 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "globals.h"
+
 #include "factory.h"
 #include "geometry.h"
 #include "point.h"
@@ -29,7 +31,7 @@ static VALUE method_line_string_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_line_string;
+    result = rgeo_feature_line_string_module;
   }
   return result;
 }
@@ -43,7 +45,7 @@ static VALUE method_linear_ring_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_linear_ring;
+    result = rgeo_feature_linear_ring_module;
   }
   return result;
 }
@@ -57,7 +59,7 @@ static VALUE method_line_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_line;
+    result = rgeo_feature_line_module;
   }
   return result;
 }
@@ -264,7 +266,7 @@ static VALUE method_line_string_project_point(VALUE self, VALUE point)
   factory_data = RGEO_FACTORY_DATA_PTR(factory);
 
   if(self_geom && point) {
-    geos_point = rgeo_convert_to_geos_geometry(factory, point, factory_data->globals->geos_point);
+    geos_point = rgeo_convert_to_geos_geometry(factory, point, rgeo_geos_point_class);
     location = GEOSProject_r(self_data->geos_context, self_geom, geos_point);
     result = DBL2NUM(location);
   }
@@ -290,7 +292,7 @@ static VALUE method_line_string_interpolate_point(VALUE self, VALUE loc_num)
 
   if(self_geom) {
     geos_point = GEOSInterpolate_r(self_data->geos_context, self_geom, location);
-    result = rgeo_wrap_geos_geometry(factory, geos_point, factory_data->globals->geos_point);
+    result = rgeo_wrap_geos_geometry(factory, geos_point, rgeo_geos_point_class);
   }
 
   return result;
@@ -343,7 +345,7 @@ static VALUE method_line_string_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_coordseqs_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom, RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
+    result = rgeo_geos_geometries_strict_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom);
   }
   return result;
 }
@@ -358,8 +360,7 @@ static VALUE method_line_string_hash(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   factory = self_data->factory;
   hash = rb_hash_start(0);
-  hash = rgeo_geos_objbase_hash(factory,
-    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_line_string, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_line_string_module, hash);
   hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -374,8 +375,7 @@ static VALUE method_linear_ring_hash(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   factory = self_data->factory;
   hash = rb_hash_start(0);
-  hash = rgeo_geos_objbase_hash(factory,
-    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_linear_ring, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_linear_ring_module, hash);
   hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -390,8 +390,7 @@ static VALUE method_line_hash(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   factory = self_data->factory;
   hash = rb_hash_start(0);
-  hash = rgeo_geos_objbase_hash(factory,
-    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_line, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_line_module, hash);
   hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -415,7 +414,7 @@ static GEOSCoordSequence* coord_seq_from_array(VALUE factory, VALUE array, char
 
   Check_Type(array, T_ARRAY);
   factory_data = RGEO_FACTORY_DATA_PTR(factory);
-  point_type = factory_data->globals->feature_point;
+  point_type = rgeo_feature_point_module;
   len = (unsigned int)RARRAY_LEN(array);
   has_z = (char)(RGEO_FACTORY_DATA_PTR(factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
   dims = has_z ? 3 : 2;
@@ -448,7 +447,7 @@ static GEOSCoordSequence* coord_seq_from_array(VALUE factory, VALUE array, char
       }
     }
     if (!good) {
-      free(coords);
+      FREE(coords);
       return NULL;
     }
   }
@@ -473,7 +472,7 @@ static GEOSCoordSequence* coord_seq_from_array(VALUE factory, VALUE array, char
       GEOSCoordSeq_setZ_r(context, coord_seq, len, has_z ? coords[2] : 0);
     }
   }
-  free(coords);
+  FREE(coords);
   return coord_seq;
 }
 
@@ -491,7 +490,7 @@ static VALUE cmethod_create_line_string(VALUE module, VALUE factory, VALUE array
     factory_data = RGEO_FACTORY_DATA_PTR(factory);
     geom = GEOSGeom_createLineString_r(factory_data->geos_context, coord_seq);
     if (geom) {
-      result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_line_string);
+      result = rgeo_wrap_geos_geometry(factory, geom, rgeo_geos_line_string_class);
     }
   }
   return result;
@@ -511,7 +510,7 @@ static VALUE cmethod_create_linear_ring(VALUE module, VALUE factory, VALUE array
     factory_data = RGEO_FACTORY_DATA_PTR(factory);
     geom = GEOSGeom_createLinearRing_r(factory_data->geos_context, coord_seq);
     if (geom) {
-      result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_linear_ring);
+      result = rgeo_wrap_geos_geometry(factory, geom, rgeo_geos_linear_ring_class);
     }
   }
   return result;
@@ -557,7 +556,7 @@ static VALUE cmethod_create_line(VALUE module, VALUE factory, VALUE start, VALUE
   result = Qnil;
   factory_data = RGEO_FACTORY_DATA_PTR(factory);
   has_z = (char)(factory_data->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
-  point_type = factory_data->globals->feature_point;
+  point_type = rgeo_feature_point_module;
   context = factory_data->geos_context;
 
   start_geom = rgeo_convert_to_geos_geometry(factory, start, point_type);
@@ -570,7 +569,7 @@ static VALUE cmethod_create_line(VALUE module, VALUE factory, VALUE start, VALUE
         populate_geom_into_coord_seq(context, end_geom, coord_seq, 1, has_z);
         geom = GEOSGeom_createLineString_r(context, coord_seq);
         if (geom) {
-          result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_line);
+          result = rgeo_wrap_geos_geometry(factory, geom, rgeo_geos_line_class);
         }
       }
     }
@@ -631,26 +630,26 @@ static VALUE cmethod_linear_ring_copy_from(VALUE klass, VALUE factory, VALUE ori
 }
 
 
-void rgeo_init_geos_line_string(RGeo_Globals* globals)
+void rgeo_init_geos_line_string()
 {
   VALUE geos_line_string_methods;
   VALUE geos_linear_ring_methods;
   VALUE geos_line_methods;
 
   // Class methods for CAPILineStringImpl
-  rb_define_module_function(globals->geos_line_string, "create", cmethod_create_line_string, 2);
-  rb_define_module_function(globals->geos_line_string, "_copy_from", cmethod_line_string_copy_from, 2);
+  rb_define_module_function(rgeo_geos_line_string_class, "create", cmethod_create_line_string, 2);
+  rb_define_module_function(rgeo_geos_line_string_class, "_copy_from", cmethod_line_string_copy_from, 2);
 
   // Class methods for CAPILinearRingImpl
-  rb_define_module_function(globals->geos_linear_ring, "create", cmethod_create_linear_ring, 2);
-  rb_define_module_function(globals->geos_linear_ring, "_copy_from", cmethod_linear_ring_copy_from, 2);
+  rb_define_module_function(rgeo_geos_linear_ring_class, "create", cmethod_create_linear_ring, 2);
+  rb_define_module_function(rgeo_geos_linear_ring_class, "_copy_from", cmethod_linear_ring_copy_from, 2);
 
   // Class methods for CAPILineImpl
-  rb_define_module_function(globals->geos_line, "create", cmethod_create_line, 3);
-  rb_define_module_function(globals->geos_line, "_copy_from", cmethod_line_copy_from, 2);
+  rb_define_module_function(rgeo_geos_line_class, "create", cmethod_create_line, 3);
+  rb_define_module_function(rgeo_geos_line_class, "_copy_from", cmethod_line_copy_from, 2);
 
   // CAPILineStringMethods module
-  geos_line_string_methods = rb_define_module_under(globals->geos_module, "CAPILineStringMethods");
+  geos_line_string_methods = rb_define_module_under(rgeo_geos_module, "CAPILineStringMethods");
   rb_define_method(geos_line_string_methods, "rep_equals?", method_line_string_eql, 1);
   rb_define_method(geos_line_string_methods, "eql?", method_line_string_eql, 1);
   rb_define_method(geos_line_string_methods, "hash", method_line_string_hash, 0);
@@ -668,12 +667,12 @@ void rgeo_init_geos_line_string(RGeo_Globals* globals)
   rb_define_method(geos_line_string_methods, "coordinates", method_line_string_coordinates, 0);
 
   // CAPILinearRingMethods module
-  geos_linear_ring_methods = rb_define_module_under(globals->geos_module, "CAPILinearRingMethods");
+  geos_linear_ring_methods = rb_define_module_under(rgeo_geos_module, "CAPILinearRingMethods");
   rb_define_method(geos_linear_ring_methods, "geometry_type", method_linear_ring_geometry_type, 0);
   rb_define_method(geos_linear_ring_methods, "hash", method_linear_ring_hash, 0);
 
   // CAPILineMethods module
-  geos_line_methods = rb_define_module_under(globals->geos_module, "CAPILineMethods");
+  geos_line_methods = rb_define_module_under(rgeo_geos_module, "CAPILineMethods");
   rb_define_method(geos_line_methods, "geometry_type", method_line_geometry_type, 0);
   rb_define_method(geos_line_methods, "hash", method_line_hash, 0);
 }

data/ext/geos_c_impl/line_string.h

@@ -9,8 +9,6 @@
 #include <ruby.h>
 #include <geos_c.h>
 
-#include "factory.h"
-
 RGEO_BEGIN_C
 
 
@@ -18,7 +16,7 @@ RGEO_BEGIN_C
   Initializes the line string module. This should be called after
   the geometry module is initialized.
 */
-void rgeo_init_geos_line_string(RGeo_Globals* globals);
+void rgeo_init_geos_line_string();
 
 /*
   Determines whether the given GEOS line string is closed.

data/ext/geos_c_impl/main.c

@@ -9,6 +9,8 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "ruby_more.h"
+#include "globals.h"
 #include "errors.h"
 
 #include "factory.h"
@@ -26,15 +28,14 @@ RGEO_BEGIN_C
 void Init_geos_c_impl()
 {
 #ifdef RGEO_GEOS_SUPPORTED
-  RGeo_Globals* globals;
-
-  globals = rgeo_init_geos_factory();
-  rgeo_init_geos_geometry(globals);
-  rgeo_init_geos_point(globals);
-  rgeo_init_geos_line_string(globals);
-  rgeo_init_geos_polygon(globals);
-  rgeo_init_geos_geometry_collection(globals);
-  rgeo_init_geos_analysis(globals);
+  rgeo_init_geos_globals();
+  rgeo_init_geos_factory();
+  rgeo_init_geos_geometry();
+  rgeo_init_geos_point();
+  rgeo_init_geos_line_string();
+  rgeo_init_geos_polygon();
+  rgeo_init_geos_geometry_collection();
+  rgeo_init_geos_analysis();
   rgeo_init_geos_errors();
 #endif
 }

data/ext/geos_c_impl/point.c

@@ -9,6 +9,8 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "globals.h"
+
 #include "factory.h"
 #include "geometry.h"
 #include "point.h"
@@ -26,7 +28,7 @@ static VALUE method_point_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_point;
+    result = rgeo_feature_point_module;
   }
   return result;
 }
@@ -153,7 +155,7 @@ static VALUE method_point_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_coordseqs_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom, RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
+    result = rgeo_geos_geometries_strict_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom);
   }
   return result;
 }
@@ -168,8 +170,7 @@ static VALUE method_point_hash(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   factory = self_data->factory;
   hash = rb_hash_start(0);
-  hash = rgeo_geos_objbase_hash(factory,
-    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_point, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_point_module, hash);
   hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -182,15 +183,15 @@ static VALUE cmethod_create(VALUE module, VALUE factory, VALUE x, VALUE y, VALUE
 }
 
 
-void rgeo_init_geos_point(RGeo_Globals* globals)
+void rgeo_init_geos_point()
 {
   VALUE geos_point_methods;
 
   // Class methods for CAPIPointImpl
-  rb_define_module_function(globals->geos_point, "create", cmethod_create, 4);
+  rb_define_module_function(rgeo_geos_point_class, "create", cmethod_create, 4);
 
   // CAPIPointMethods module
-  geos_point_methods = rb_define_module_under(globals->geos_module, "CAPIPointMethods");
+  geos_point_methods = rb_define_module_under(rgeo_geos_module, "CAPIPointMethods");
   rb_define_method(geos_point_methods, "rep_equals?", method_point_eql, 1);
   rb_define_method(geos_point_methods, "eql?", method_point_eql, 1);
   rb_define_method(geos_point_methods, "hash", method_point_hash, 0);
@@ -221,7 +222,7 @@ VALUE rgeo_create_geos_point(VALUE factory, double x, double y, double z)
         if (GEOSCoordSeq_setZ_r(context, coord_seq, 0, z)) {
           geom = GEOSGeom_createPoint_r(context, coord_seq);
           if (geom) {
-            result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_point);
+            result = rgeo_wrap_geos_geometry(factory, geom, rgeo_geos_point_class);
           }
         }
       }

data/ext/geos_c_impl/point.h

@@ -8,8 +8,6 @@
 
 #include <ruby.h>
 
-#include "factory.h"
-
 RGEO_BEGIN_C
 
 
@@ -17,7 +15,7 @@ RGEO_BEGIN_C
   Initializes the point module. This should be called after
   the geometry module is initialized.
 */
-void rgeo_init_geos_point(RGeo_Globals* globals);
+void rgeo_init_geos_point();
 
 /*
   Creates a 3d point and returns the ruby object.

data/ext/geos_c_impl/polygon.c

@@ -10,6 +10,8 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "globals.h"
+
 #include "factory.h"
 #include "geometry.h"
 #include "line_string.h"
@@ -28,7 +30,7 @@ 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_polygons_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom, RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
+    result = rgeo_geos_geometries_strict_eql(self_data->geos_context, self_data->geom, RGEO_GEOMETRY_DATA_PTR(rhs)->geom);
   }
   return result;
 }
@@ -43,8 +45,7 @@ static VALUE method_polygon_hash(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   factory = self_data->factory;
   hash = rb_hash_start(0);
-  hash = rgeo_geos_objbase_hash(factory,
-    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_polygon, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_polygon_module, hash);
   hash = rgeo_geos_polygon_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -58,7 +59,7 @@ static VALUE method_polygon_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_polygon;
+    result = rgeo_feature_polygon_module;
   }
   return result;
 }
@@ -93,7 +94,7 @@ 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_FACTORY_DATA_PTR(self_data->factory)->globals->geos_point);
+    result = rgeo_wrap_geos_geometry(self_data->factory, GEOSGetCentroid_r(self_data->geos_context, self_geom), rgeo_geos_point_class);
   }
   return result;
 }
@@ -109,7 +110,7 @@ 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_FACTORY_DATA_PTR(self_data->factory)->globals->geos_point);
+    result = rgeo_wrap_geos_geometry(self_data->factory, GEOSPointOnSurface_r(self_data->geos_context, self_geom), rgeo_geos_point_class);
   }
   return result;
 }
@@ -145,7 +146,7 @@ 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_FACTORY_DATA_PTR(self_data->factory)->globals->geos_linear_ring);
+    result = rgeo_wrap_geos_geometry_clone(self_data->factory, GEOSGetExteriorRing_r(self_data->geos_context, self_geom), rgeo_geos_linear_ring_class);
   }
   return result;
 }
@@ -191,7 +192,7 @@ static VALUE method_polygon_interior_ring_n(VALUE self, VALUE n)
       if (i < num) {
         result = rgeo_wrap_geos_geometry_clone(self_data->factory,
           GEOSGetInteriorRingN_r(self_context, self_geom, i),
-          RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->geos_linear_ring);
+          rgeo_geos_linear_ring_class);
       }
     }
   }
@@ -219,9 +220,8 @@ static VALUE method_polygon_interior_rings(VALUE self)
     if (count >= 0) {
       result = rb_ary_new2(count);
       factory = self_data->factory;
-      linear_ring_class = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->geos_linear_ring;
       for (i=0; i<count; ++i) {
-        rb_ary_store(result, i, rgeo_wrap_geos_geometry_clone(factory, GEOSGetInteriorRingN_r(self_context, self_geom, i), linear_ring_class));
+        rb_ary_store(result, i, rgeo_wrap_geos_geometry_clone(factory, GEOSGetInteriorRingN_r(self_context, self_geom, i), rgeo_geos_linear_ring_class));
       }
     }
   }
@@ -241,50 +241,57 @@ static VALUE cmethod_create(VALUE module, VALUE factory, VALUE exterior, VALUE i
   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 = factory_data->globals->feature_linear_ring;
-  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;
-        }
+  linear_ring_type = rgeo_feature_linear_ring_module;
+  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; }
+
+  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, &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, factory_data->globals->geos_polygon);
-        }
+      if (state) {
+        break;
       }
-      for (i=0; i<actual_len; ++i) {
-        GEOSGeom_destroy_r(context, interior_geoms[i]);
+    }
+    if (len == actual_len) {
+      polygon = GEOSGeom_createPolygon_r(context, 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_r(context, interior_geoms[i]);
+    }
+    FREE(interior_geoms);
   }
+  GEOSGeom_destroy_r(context, exterior_geom);
+  if (state) { rb_exc_raise(rb_errinfo()); }
   return Qnil;
 }
 
 
-void rgeo_init_geos_polygon(RGeo_Globals* globals)
+void rgeo_init_geos_polygon()
 {
   VALUE geos_polygon_methods;
 
   // Class methods for CAPIPolygonImpl
-  rb_define_module_function(globals->geos_polygon, "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(globals->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);
@@ -299,42 +306,6 @@ void rgeo_init_geos_polygon(RGeo_Globals* globals)
   rb_define_method(geos_polygon_methods, "coordinates", method_polygon_coordinates, 0);
 }
 
-
-VALUE rgeo_geos_polygons_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z)
-{
-  VALUE result;
-  int len1;
-  int len2;
-  int i;
-
-  result = Qnil;
-  if (geom1 && geom2) {
-    result = rgeo_geos_coordseqs_eql(context, GEOSGetExteriorRing_r(context, geom1), GEOSGetExteriorRing_r(context, geom2), check_z);
-    if (RTEST(result)) {
-      len1 = GEOSGetNumInteriorRings_r(context, geom1);
-      len2 = GEOSGetNumInteriorRings_r(context, geom2);
-      if (len1 >= 0 && len2 >= 0) {
-        if (len1 == len2) {
-          for (i=0; i<len1; ++i) {
-            result = rgeo_geos_coordseqs_eql(context, GEOSGetInteriorRingN_r(context, geom1, i), GEOSGetInteriorRingN_r(context, geom2, i), check_z);
-            if (!RTEST(result)) {
-              break;
-            }
-          }
-        }
-        else {
-          result = Qfalse;
-        }
-      }
-      else {
-        result = Qnil;
-      }
-    }
-  }
-  return result;
-}
-
-
 st_index_t rgeo_geos_polygon_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash)
 {
   unsigned int len;

data/ext/geos_c_impl/polygon.h

@@ -9,8 +9,6 @@
 #include <ruby.h>
 #include <geos_c.h>
 
-#include "factory.h"
-
 RGEO_BEGIN_C
 
 
@@ -18,7 +16,7 @@ RGEO_BEGIN_C
   Initializes the polygon module. This should be called after
   the geometry module is initialized.
 */
-void rgeo_init_geos_polygon(RGeo_Globals* globals);
+void rgeo_init_geos_polygon();
 
 /*
   Comopares the values of two GEOS polygons. The two given geometries MUST

data/ext/geos_c_impl/preface.h

@@ -27,6 +27,11 @@
 #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
@@ -42,3 +47,10 @@
 #define RGEO_BEGIN_C
 #define RGEO_END_C
 #endif
+
+// https://ozlabs.org/~rusty/index.cgi/tech/2008-04-01.html
+#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,65 @@
+/*
+	Utilities for the ruby CAPI
+*/
+
+#ifndef RGEO_GEOS_RUBY_MORE_INCLUDED
+#define RGEO_GEOS_RUBY_MORE_INCLUDED
+
+#include <ruby.h>
+
+#include "preface.h"
+#include "ruby_more.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,16 @@
+/*
+	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