rgeo 3.0.0.pre.rc.1 → 3.0.0.pre.rc.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e26b01fb2fff6915756d98e206ee4bdabefeaceadae3cd0b85cb7be9ee6d8285
-  data.tar.gz: 9b94dd4e6c57e9fa5ab07c7b5fb9c622a52d843b67d146b52454933cb817a4a1
+  metadata.gz: 939fdbb8c9bbcb94342b99f952ad5524cb436683ea054bcab0aaa408f362ac2a
+  data.tar.gz: 4cd0c59ee3e08947c646c1b7e5c9a9755c44a0a87459437754867bbb5c2e304e
 SHA512:
-  metadata.gz: 9adb8cc283c8663fb0a178eeb7a1629fe466265f7fa15c54d4e8dac4188646a2682f591a3e76d12271df5dc6c875961833600b88952d035f824933bd454211de
-  data.tar.gz: c1f7e26d5a5edcc060cac2efaa782a586c9ee95e1dda08f7af771648ecc1ea2373a1e4ba9053aae00288332e401370c7f61e254367231ceabb4fb36ad5406209
+  metadata.gz: e6f02199e30b35334156d3a1107213b6dab9028572e423d2f0f6072a7a2032586e26dfa5a594a8132b33d4071f0d55f6bd75dcd60d1e5a60df4bde0c51b7a78f
+  data.tar.gz: 20404c7de6aec61e04eae659253ddf16f518afce40c64274d261acc1a160f5420866c8188fed18425e1a55788e5041ff9b7a93c653f61cdde0a7ce15dccfa1a1

data/README.md

@@ -1,7 +1,7 @@
 ## RGeo
 
 [![Gem Version](https://badge.fury.io/rb/rgeo.svg)](http://badge.fury.io/rb/rgeo)
-[![CI](https://github.com/rgeo/rgeo/workflows/CI/badge.svg)](https://github.com/rgeo/rgeo/actions?query=workflow%3ACI+branch%3Amaster+event%3Apush)
+[![CI](https://github.com/rgeo/rgeo/workflows/CI/badge.svg)](https://github.com/rgeo/rgeo/actions?query=workflow%3ACI+branch%3Amain+event%3Apush)
 
 RGeo is a geospatial data library for Ruby.
 
@@ -109,7 +109,7 @@ ActiveRecord connection adapter for SpatiaLite, based on sqlite3 (*not maintaine
 RDoc Documentation is available at https://www.rubydoc.info/gems/rgeo
 
 Contributions are welcome. Please read the
-[Contributing guidelines](https://github.com/rgeo/rgeo/blob/master/CONTRIBUTING.md).
+[Contributing guidelines](https://github.com/rgeo/rgeo/blob/main/CONTRIBUTING.md).
 
 Support may be available on the
 [rgeo-users google group](https://groups.google.com/forum/#!forum/rgeo-users)
@@ -124,14 +124,14 @@ generate documentation locally if you're working on RGeo: `yardoc server`.
 
 Here's the current list of available topics:
 
-- [An introduction to Spatial Programming With RGeo](https://github.com/rgeo/rgeo/blob/master/doc/An-Introduction-to-Spatial-Programming-With-RGeo.md)
-- [Enable GEOS and Proj4 on Heroku](https://github.com/rgeo/rgeo/blob/master/doc/Enable-GEOS-and-Proj4-on-Heroku.md)
-- [Installing GEOS](https://github.com/rgeo/rgeo/blob/master/doc/Installing-GEOS.md)
-- [Factory Compatibility](https://github.com/rgeo/rgeo/blob/master/doc/Factory-Compatibility.md)
-- [Which factory should I use?](https://github.com/rgeo/rgeo/blob/master/doc/Which-factory-should-I-use.md)
-- [Geometry validity handling](https://github.com/rgeo/rgeo/blob/master/doc/Geometry-Validity.md)
-- [Examples](https://github.com/rgeo/rgeo/blob/master/doc/Examples.md)
-- [Who uses `rgeo`?](https://github.com/rgeo/rgeo/blob/master/doc/Gallery.md)
+- [An introduction to Spatial Programming With RGeo](https://github.com/rgeo/rgeo/blob/main/doc/An-Introduction-to-Spatial-Programming-With-RGeo.md)
+- [Enable GEOS and Proj4 on Heroku](https://github.com/rgeo/rgeo/blob/main/doc/Enable-GEOS-and-Proj4-on-Heroku.md)
+- [Installing GEOS](https://github.com/rgeo/rgeo/blob/main/doc/Installing-GEOS.md)
+- [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)
+- [Examples](https://github.com/rgeo/rgeo/blob/main/doc/Examples.md)
+- [Who uses `rgeo`?](https://github.com/rgeo/rgeo/blob/main/doc/Gallery.md)
 
 You can see an exhaustive and up to date list at https://rubydoc.info/gems/rgeo/index.
 ### Acknowledgments
@@ -158,4 +158,4 @@ by [J Smith](https://github.com/dark-panda).
 
 Copyright (c) Daniel Azuma, Tee Parham
 
-[License](https://github.com/rgeo/rgeo/blob/master/LICENSE.txt)
+[License](https://github.com/rgeo/rgeo/blob/main/LICENSE.txt)

data/ext/geos_c_impl/factory.c

@@ -13,15 +13,15 @@
 #include <stdarg.h>
 #include <stdio.h>
 
-#include "globals.h"
-
+#include "errors.h"
 #include "factory.h"
+#include "globals.h"
 #include "geometry.h"
-#include "point.h"
+#include "geometry_collection.h"
 #include "line_string.h"
+#include "point.h"
 #include "polygon.h"
-#include "geometry_collection.h"
-#include "errors.h"
+#include "ruby_more.h"
 
 RGEO_BEGIN_C
 
@@ -110,7 +110,7 @@ static void destroy_factory_func(void* data)
     GEOSWKBWriter_destroy_r(context, factory_data->marshal_wkb_writer);
   }
   finishGEOS_r(context);
-  free(factory_data);
+  FREE(factory_data);
 }
 
 
@@ -132,7 +132,7 @@ static void destroy_geometry_func(void* data)
   {
     GEOSPreparedGeom_destroy_r(geometry_data->geos_context, prep);
   }
-  free(geometry_data);
+  FREE(geometry_data);
 }
 
 
@@ -546,7 +546,7 @@ static VALUE cmethod_factory_create(VALUE klass, VALUE flags, VALUE srid, VALUE
       result = TypedData_Wrap_Struct(klass, &rgeo_factory_type, data);
     }
     else {
-      free(data);
+      FREE(data);
     }
   }
   return result;
@@ -860,38 +860,39 @@ const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALU
   return RGEO_GEOMETRY_DATA_PTR(object)->geom;
 }
 
-
-GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, VALUE type, VALUE* klasses)
+GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, VALUE type, VALUE* klasses, int *state)
 {
   VALUE object;
   GEOSGeometry* geom;
   RGeo_GeometryData* object_data;
   const GEOSPreparedGeometry* prep;
-
   if (klasses) {
     *klasses = Qnil;
   }
-  object = rb_funcall(rgeo_feature_module, rb_intern("cast"), 5, obj, factory, type, ID2SYM(rb_intern("force_new")), ID2SYM(rb_intern("keep_subtype")));
-  geom = NULL;
-  if (!NIL_P(object)) {
-    object_data = RGEO_GEOMETRY_DATA_PTR(object);
-    geom = object_data->geom;
-    if (klasses) {
-      *klasses = object_data->klasses;
-      if (NIL_P(*klasses)) {
-        *klasses = CLASS_OF(object);
-      }
-    }
-    prep = object_data->prep;
-    if (prep && prep != (GEOSPreparedGeometry*)1 && prep != (GEOSPreparedGeometry*)2) {
-      GEOSPreparedGeom_destroy_r(object_data->geos_context, prep);
+
+  object = rb_protect_funcall(rgeo_feature_module, rb_intern("cast"), state, 5, obj, factory, type, ID2SYM(rb_intern("force_new")), ID2SYM(rb_intern("keep_subtype")));
+  if (*state || NIL_P(object)) {
+    return NULL;
+  }
+
+  object_data = RGEO_GEOMETRY_DATA_PTR(object);
+  geom = object_data->geom;
+  if (klasses) {
+    *klasses = object_data->klasses;
+    if (NIL_P(*klasses)) {
+      *klasses = CLASS_OF(object);
     }
-    object_data->geos_context = NULL;
-    object_data->geom = NULL;
-    object_data->prep = NULL;
-    object_data->factory = Qnil;
-    object_data->klasses = Qnil;
   }
+  prep = object_data->prep;
+  if (prep && prep != (GEOSPreparedGeometry*)1 && prep != (GEOSPreparedGeometry*)2) {
+    GEOSPreparedGeom_destroy_r(object_data->geos_context, prep);
+  }
+  object_data->geos_context = NULL;
+  object_data->geom = NULL;
+  object_data->prep = NULL;
+  object_data->factory = Qnil;
+  object_data->klasses = Qnil;
+
   return geom;
 }
 

data/ext/geos_c_impl/factory.h

@@ -167,8 +167,15 @@ const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALU
   result of this function to build a GEOS-backed clone of the original
   geometry, or to include the given geometry in a collection while keeping
   the klasses intact.
+
+  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.
 */
-GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, VALUE type, VALUE* klasses);
+GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, VALUE type, VALUE* klasses, int* state);
 
 /*
   Returns 1 if the given ruby object is a GEOS Geometry implementation,

data/ext/geos_c_impl/geometry.c

@@ -386,6 +386,11 @@ static VALUE method_geometry_equals(VALUE self, VALUE rhs)
   GEOSContextHandle_t self_context;
   char val;
 
+  // Shortcut when self and rhs are the same object.
+  if (self == rhs) {
+    return Qtrue;
+  }
+
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
@@ -1058,6 +1063,32 @@ static VALUE method_geometry_invalid_reason(VALUE self)
   return result;
 }
 
+static VALUE method_geometry_invalid_reason_location(VALUE self)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  GEOSGeometry* location = NULL;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (self_geom) {
+    // We use NULL there to tell GEOS that we don't care about the reason.
+    switch(GEOSisValidDetail_r(self_data->geos_context, self_geom, 0, NULL, &location)) {
+      case 0: // invalid
+        result = rgeo_wrap_geos_geometry(self_data->factory, location, Qnil);
+      case 1: // valid
+        break;
+      case 2: // exception
+        break;
+      default:
+        break;
+    };
+  }
+  return result;
+}
+
 static VALUE method_geometry_make_valid(VALUE self)
 {
   RGeo_GeometryData* self_data;
@@ -1090,6 +1121,43 @@ static VALUE method_geometry_point_on_surface(VALUE self)
   return result;
 }
 
+/**
+  * call-seq:
+  *   some.polygonize -> RGeo::Feature::GeometryCollection
+  *
+  * Polygonizes a set of Geometries which contain linework that
+  * represents the edges of a planar graph.
+  *
+  * All types of Geometry are accepted as input;
+  * the constituent linework is extracted as the edges to be polygonized.
+  * 
+  * The edges must be correctly noded;
+  * that is, they must only meet at their endpoints and not overlap anywhere.
+  *
+  * @see https://libgeos.org/doxygen/geos__c_8h.html#a9d98e448d3b846d591c726d1c0000d25 GEOSPolygonize
+  */
+static VALUE method_geometry_polygonize(VALUE self)
+{
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  GEOSGeometry* geos_polygon_collection;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
+  if (self_geom) {
+    geos_polygon_collection = GEOSPolygonize_r(self_data->geos_context, &self_geom, 1);
+
+    if (geos_polygon_collection == NULL) {
+      rb_raise(rb_eGeosError, "GEOS can't polygonize this geometry.");
+    }
+
+    result = rgeo_wrap_geos_geometry(self_data->factory, geos_polygon_collection, Qnil);
+  }
+  return result;
+}
+
 VALUE rgeo_geos_geometries_strict_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2)
 {
   switch (GEOSEqualsExact_r(context, geom1, geom2, 0.0)) {
@@ -1156,8 +1224,10 @@ void rgeo_init_geos_geometry()
   rb_define_method(geos_geometry_methods, "sym_difference", method_geometry_sym_difference, 1);
   rb_define_method(geos_geometry_methods, "valid?", method_geometry_is_valid, 0);
   rb_define_method(geos_geometry_methods, "invalid_reason", method_geometry_invalid_reason, 0);
+  rb_define_method(geos_geometry_methods, "invalid_reason_location", method_geometry_invalid_reason_location, 0);
   rb_define_method(geos_geometry_methods, "point_on_surface", method_geometry_point_on_surface, 0);
   rb_define_method(geos_geometry_methods, "make_valid", method_geometry_make_valid, 0);
+  rb_define_method(geos_geometry_methods, "polygonize", method_geometry_polygonize, 0);
 }
 
 

data/ext/geos_c_impl/geometry_collection.c

@@ -10,16 +10,16 @@
 #include <ruby.h>
 #include <geos_c.h>
 
-#include "globals.h"
 
+#include "coordinates.h"
+#include "errors.h"
 #include "factory.h"
 #include "geometry.h"
+#include "geometry_collection.h"
+#include "globals.h"
 #include "line_string.h"
 #include "polygon.h"
-#include "geometry.h"
-#include "geometry_collection.h"
 
-#include "coordinates.h"
 
 RGEO_BEGIN_C
 
@@ -44,17 +44,19 @@ static VALUE create_geometry_collection(VALUE module, int type, VALUE factory, V
   VALUE cast_type;
   GEOSGeometry* geom;
   GEOSGeometry* collection;
+  int state = 0;
 
   result = Qnil;
   Check_Type(array, T_ARRAY);
   len = (unsigned int)RARRAY_LEN(array);
   geoms = ALLOC_N(GEOSGeometry*, len == 0 ? 1 : len);
-  if (geoms) {
-    factory_data = RGEO_FACTORY_DATA_PTR(factory);
-    geos_context = factory_data->geos_context;
-    klasses = Qnil;
-    cast_type = Qnil;
-    switch (type) {
+  if (!geoms) { rb_raise(rb_eRGeoError, "not enough memory available"); }
+
+  factory_data = RGEO_FACTORY_DATA_PTR(factory);
+  geos_context = factory_data->geos_context;
+  klasses = Qnil;
+  cast_type = Qnil;
+  switch (type) {
     case GEOS_MULTIPOINT:
       cast_type = rgeo_feature_point_module;
       break;
@@ -64,46 +66,47 @@ static VALUE create_geometry_collection(VALUE module, int type, VALUE factory, V
     case GEOS_MULTIPOLYGON:
       cast_type = rgeo_feature_polygon_module;
       break;
+  }
+  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;
     }
-    for (i=0; i<len; ++i) {
-      geom = rgeo_convert_to_detached_geos_geometry(rb_ary_entry(array, i), factory, cast_type, &klass);
-      if (!geom) {
-        break;
-      }
-      geoms[i] = geom;
-      if (!NIL_P(klass) && NIL_P(klasses)) {
-        klasses = rb_ary_new2(len);
-        for (j=0; j<i; ++j) {
-          rb_ary_push(klasses, Qnil);
-        }
-      }
-      if (!NIL_P(klasses)) {
-        rb_ary_push(klasses, klass);
-      }
-    }
-    if (i != len) {
+    geoms[i] = geom;
+    if (!NIL_P(klass) && NIL_P(klasses)) {
+      klasses = rb_ary_new2(len);
       for (j=0; j<i; ++j) {
-        GEOSGeom_destroy_r(geos_context, geoms[j]);
+        rb_ary_push(klasses, Qnil);
       }
     }
-    else {
-      collection = GEOSGeom_createCollection_r(geos_context, 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.
+    if (!NIL_P(klasses)) {
+      rb_ary_push(klasses, klass);
     }
-    free(geoms);
+  }
+  if (i != len) {
+    for (j=0; j<i; ++j) {
+      GEOSGeom_destroy_r(geos_context, geoms[j]);
+    }
+  }
+  else {
+    collection = GEOSGeom_createCollection_r(geos_context, 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 $!
   }
 
   return result;
 }
 
-
 /**** RUBY METHOD DEFINITIONS ****/
 
 

data/ext/geos_c_impl/line_string.c

@@ -447,7 +447,7 @@ static GEOSCoordSequence* coord_seq_from_array(VALUE factory, VALUE array, char
       }
     }
     if (!good) {
-      free(coords);
+      FREE(coords);
       return NULL;
     }
   }
@@ -472,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;
 }
 

data/ext/geos_c_impl/main.c

@@ -9,8 +9,8 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "ruby_more.h"
 #include "globals.h"
-
 #include "errors.h"
 
 #include "factory.h"

data/ext/geos_c_impl/polygon.c

@@ -241,37 +241,44 @@ 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 = 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; }
+
+  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, 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_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;
 }
 

data/ext/geos_c_impl/preface.h

@@ -50,3 +50,7 @@
 
 // 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

data/lib/rgeo/cartesian/factory.rb

@@ -22,6 +22,11 @@ module RGeo
       def initialize(opts = {})
         @has_z = opts[:has_z_coordinate] ? true : false
         @has_m = opts[:has_m_coordinate] ? true : false
+        @coordinate_dimension = 2
+        @coordinate_dimension += 1 if @has_z
+        @coordinate_dimension += 1 if @has_m
+        @spatial_dimension = @has_z ? 3 : 2
+
         @proj4 = opts[:proj4]
         if @proj4 && CoordSys.check!(:proj4)
           if @proj4.is_a?(String) || @proj4.is_a?(Hash)
@@ -33,13 +38,6 @@ module RGeo
         if @coord_sys.is_a?(String)
           @coord_sys = CoordSys::CS.create_from_wkt(@coord_sys)
         end
-        if (!@proj4 || !@coord_sys) && srid && (db = opts[:srs_database])
-          entry = db.get(srid.to_i)
-          if entry
-            @proj4 ||= entry.proj4
-            @coord_sys ||= entry.coord_sys
-          end
-        end
         srid ||= @coord_sys.authority_code if @coord_sys
         @srid = srid.to_i
         @buffer_resolution = opts[:buffer_resolution].to_i
@@ -74,6 +72,7 @@ module RGeo
           @wkb_parser = WKRep::WKBParser.new(self)
         end
       end
+      attr_reader :coordinate_dimension, :spatial_dimension
 
       # Equivalence test.
 

data/lib/rgeo/cartesian/feature_classes.rb

@@ -6,6 +6,8 @@
 #
 # -----------------------------------------------------------------------------
 
+require_relative "../impl_helper/validity_check"
+
 module RGeo
   module Cartesian
     class PointImpl # :nodoc:

data/lib/rgeo/cartesian/feature_methods.rb

@@ -17,6 +17,22 @@ module RGeo
         BoundingBox.new(factory).add(self).to_geometry
       end
 
+      def coordinate_dimension
+        factory.coordinate_dimension
+      end
+
+      def spatial_dimension
+        factory.spatial_dimension
+      end
+
+      def is_3d?
+        factory.property(:has_z_coordinate)
+      end
+
+      def measured?
+        factory.property(:has_m_coordinate)
+      end
+
       private
 
       def graph