rgeo 0.2.0 → 0.2.1

data/History.rdoc

@@ -1,3 +1,9 @@
+=== 0.2.1 / 2010-12-09
+
+* Now compatible with Rubinius (version 1.1 or later).
+* Now partially compatible with JRuby (1.5 or later). A bunch of tests fail because GEOS and Proj4 are not available, hence there is no projection support and no complete Cartesian implementation. But at least RGeo loads and the basic operations work.
+* Some minor optimizations in the GEOS glue code.
+
 === 0.2.0 / 2010-12-07
 
 This is the first public alpha version of RGeo. With this version, we are soft-locking the API interfaces and will try to retain backwards compatibility from this point. Incompatible API changes may still be done, but only if considered necessary.

data/README.rdoc

@@ -39,14 +39,14 @@ Several optional modules are currently available:
   * <b>activerecord-postgis-adapter</b>
 * and more to come...
 
-=== Requirements
+=== Dependencies
 
-RGeo has the following requirements:
+RGeo is known to work with the following Ruby implementations:
 
-* Ruby 1.8.7 or later. Ruby 1.9.2 or later preferred.
-  Rubinius and JRuby are not yet supported.
-* The build system assumes a unix-like environment. Windows builds may be
-  possible, but not likely "out of the box".
+* Standard "MRI" Ruby 1.8.7 or later. (1.9.2 or later preferred.)
+* Rubinius 1.1 or later.
+* Partial support for JRuby 1.5 or later, but a bunch of features are
+  missing because GEOS and Proj are not available from Java.
 
 Some features also require the following:
 
@@ -59,6 +59,9 @@ Some features also require the following:
   may be available via your operating system's package manager, or from
   http://trac.osgeo.org/proj
 
+Note: The build system assumes a unix-like environment. Windows builds
+may be possible, but not likely "out of the box".
+
 === Installation
 
 Install RGeo as a gem:
@@ -100,7 +103,7 @@ the core library includes:
 * Implementation of the OGC coordinate system spec.
 * Integration with spatial reference system databases.
 * Ellipsoidal geography implementation, probably utilizing geographiclib.
-* Rubinius and JRuby support.
+* JRuby support via the JTS library.
 * Windows build support.
 
 Each of the current add-on modules also has its own feature roadmap, and

data/Version

@@ -1 +1 @@
-0.2.0
+0.2.1

data/ext/geos_c_impl/extconf.rb

@@ -34,39 +34,47 @@
 ;
 
 
-require 'mkmf'
-
-header_dirs_ =
-  [
-   '/usr/local/include',
-   '/usr/local/geos/include',
-   '/opt/local/include',
-   ::Config::CONFIG['includedir'],
-   '/usr/include',
-  ]
-lib_dirs_ =
-  [
-   '/usr/local/lib',
-   '/usr/local/geos/lib',
-   '/opt/local/lib',
-   ::Config::CONFIG['libdir'],
-   '/usr/lib',
-  ]
-header_dirs_.delete_if{ |path_| !::File.directory?(path_) }
-lib_dirs_.delete_if{ |path_| !::File.directory?(path_) }
-
-found_geos_ = false
-header_dirs_, lib_dirs_ = dir_config('geos', header_dirs_, lib_dirs_)
-if have_header('geos_c.h')
-  $libs << ' -lgeos -lgeos_c'
-  if have_func('initGEOS_r', 'geos_c.h')
-    found_geos_ = true
-  else
-    $libs.gsub!(' -lgeos -lgeos_c', '')
+if ::RUBY_DESCRIPTION =~ /^jruby\s/
+  
+  ::File.open('Makefile', 'w'){ |f_| f_.write(".PHONY: install\ninstall:\n") }
+  
+else
+  
+  require 'mkmf'
+  
+  header_dirs_ =
+    [
+     '/usr/local/include',
+     '/usr/local/geos/include',
+     '/opt/local/include',
+     ::Config::CONFIG['includedir'],
+     '/usr/include',
+    ]
+  lib_dirs_ =
+    [
+     '/usr/local/lib',
+     '/usr/local/geos/lib',
+     '/opt/local/lib',
+     ::Config::CONFIG['libdir'],
+     '/usr/lib',
+    ]
+  header_dirs_.delete_if{ |path_| !::File.directory?(path_) }
+  lib_dirs_.delete_if{ |path_| !::File.directory?(path_) }
+  
+  found_geos_ = false
+  header_dirs_, lib_dirs_ = dir_config('geos', header_dirs_, lib_dirs_)
+  if have_header('geos_c.h')
+    $libs << ' -lgeos -lgeos_c'
+    if have_func('initGEOS_r', 'geos_c.h')
+      found_geos_ = true
+    else
+      $libs.gsub!(' -lgeos -lgeos_c', '')
+    end
   end
+  unless found_geos_
+    puts "**** WARNING: Unable to find GEOS headers or GEOS version is too old."
+    puts "**** Compiling without GEOS support."
+  end
+  create_makefile('rgeo/geos/geos_c_impl')
+  
 end
-unless found_geos_
-  puts "**** WARNING: Unable to find GEOS headers or GEOS version is too old."
-  puts "**** Compiling without GEOS support."
-end
-create_makefile('rgeo/geos/geos_c_impl')

data/ext/geos_c_impl/factory.c

@@ -69,19 +69,20 @@ static void message_handler(const char* fmt, ...)
 
 static void destroy_factory_func(RGeo_FactoryData* data)
 {
+  GEOSContextHandle_t context = data->geos_context;
   if (data->wkt_reader) {
-    GEOSWKTReader_destroy_r(data->geos_context, data->wkt_reader);
+    GEOSWKTReader_destroy_r(context, data->wkt_reader);
   }
   if (data->wkb_reader) {
-    GEOSWKBReader_destroy_r(data->geos_context, data->wkb_reader);
+    GEOSWKBReader_destroy_r(context, data->wkb_reader);
   }
   if (data->wkt_writer) {
-    GEOSWKTWriter_destroy_r(data->geos_context, data->wkt_writer);
+    GEOSWKTWriter_destroy_r(context, data->wkt_writer);
   }
   if (data->wkb_writer) {
-    GEOSWKBWriter_destroy_r(data->geos_context, data->wkb_writer);
+    GEOSWKBWriter_destroy_r(context, data->wkb_writer);
   }
-  finishGEOS_r(data->geos_context);
+  finishGEOS_r(context);
   free(data);
 }
 
@@ -92,7 +93,7 @@ static void destroy_factory_func(RGeo_FactoryData* data)
 static void destroy_geometry_func(RGeo_GeometryData* data)
 {
   if (data->geom) {
-    GEOSGeom_destroy_r(RGEO_CONTEXT_FROM_FACTORY(data->factory), data->geom);
+    GEOSGeom_destroy_r(data->geos_context, data->geom);
   }
   free(data);
 }
@@ -153,14 +154,16 @@ static VALUE method_factory_flags(VALUE self)
 static VALUE method_factory_parse_wkt(VALUE self, VALUE str)
 {
   Check_Type(str, T_STRING);
-  GEOSWKTReader* wkt_reader = RGEO_FACTORY_DATA_PTR(self)->wkt_reader;
+  RGeo_FactoryData* self_data = RGEO_FACTORY_DATA_PTR(self);
+  GEOSContextHandle_t self_context = self_data->geos_context;
+  GEOSWKTReader* wkt_reader = self_data->wkt_reader;
   if (!wkt_reader) {
-    wkt_reader = GEOSWKTReader_create_r(RGEO_CONTEXT_FROM_FACTORY(self));
-    RGEO_FACTORY_DATA_PTR(self)->wkt_reader = wkt_reader;
+    wkt_reader = GEOSWKTReader_create_r(self_context);
+    self_data->wkt_reader = wkt_reader;
   }
   VALUE result = Qnil;
   if (wkt_reader) {
-    GEOSGeometry* geom = GEOSWKTReader_read_r(RGEO_CONTEXT_FROM_FACTORY(self), wkt_reader, RSTRING_PTR(str));
+    GEOSGeometry* geom = GEOSWKTReader_read_r(self_context, wkt_reader, RSTRING_PTR(str));
     if (geom) {
       result = rgeo_wrap_geos_geometry(self, geom, Qnil);
     }
@@ -172,14 +175,16 @@ static VALUE method_factory_parse_wkt(VALUE self, VALUE str)
 static VALUE method_factory_parse_wkb(VALUE self, VALUE str)
 {
   Check_Type(str, T_STRING);
-  GEOSWKBReader* wkb_reader = RGEO_FACTORY_DATA_PTR(self)->wkb_reader;
+  RGeo_FactoryData* self_data = RGEO_FACTORY_DATA_PTR(self);
+  GEOSContextHandle_t self_context = self_data->geos_context;
+  GEOSWKBReader* wkb_reader = self_data->wkb_reader;
   if (!wkb_reader) {
-    wkb_reader = GEOSWKBReader_create_r(RGEO_CONTEXT_FROM_FACTORY(self));
-    RGEO_FACTORY_DATA_PTR(self)->wkb_reader = wkb_reader;
+    wkb_reader = GEOSWKBReader_create_r(self_context);
+    self_data->wkb_reader = wkb_reader;
   }
   VALUE result = Qnil;
   if (wkb_reader) {
-    GEOSGeometry* geom = GEOSWKBReader_read_r(RGEO_CONTEXT_FROM_FACTORY(self), wkb_reader, (unsigned char*)RSTRING_PTR(str), (size_t)RSTRING_LEN(str));
+    GEOSGeometry* geom = GEOSWKBReader_read_r(self_context, wkb_reader, (unsigned char*)RSTRING_PTR(str), (size_t)RSTRING_LEN(str));
     if (geom) {
       result = rgeo_wrap_geos_geometry(self, geom, Qnil);
     }
@@ -223,7 +228,7 @@ RGeo_Globals* rgeo_init_geos_factory()
   RGeo_Globals* globals = ALLOC(RGeo_Globals);
   VALUE rgeo_module = rb_define_module("RGeo");
   globals->geos_module = rb_define_module_under(rgeo_module, "Geos");
-  globals->features_module = rb_define_module_under(rgeo_module, "Feature");
+  globals->feature_module = rb_define_module_under(rgeo_module, "Feature");
   
   // Add C methods to the factory.
   VALUE geos_factory_class = rb_const_get_at(globals->geos_module, rb_intern("Factory"));
@@ -250,54 +255,58 @@ VALUE rgeo_wrap_geos_geometry(VALUE factory, GEOSGeometry* geom, VALUE klass)
 {
   VALUE result = Qnil;
   if (geom || !NIL_P(klass)) {
+    RGeo_FactoryData* factory_data = NIL_P(factory) ? NULL : RGEO_FACTORY_DATA_PTR(factory);
+    GEOSContextHandle_t factory_context = factory_data ? factory_data->geos_context : NULL;
     VALUE klasses = Qnil;
     if (TYPE(klass) != T_CLASS) {
-      const char* klass_name = NULL;
+      RGeo_Globals* globals = factory_data->globals;
+      VALUE inferred_klass = Qnil;
       char is_collection = 0;
-      switch (GEOSGeomTypeId_r(RGEO_CONTEXT_FROM_FACTORY(factory), geom)) {
+      switch (GEOSGeomTypeId_r(factory_context, geom)) {
       case GEOS_POINT:
-        klass_name = "PointImpl";
+        inferred_klass = globals->geos_point;
         break;
       case GEOS_LINESTRING:
-        klass_name = "LineStringImpl";
+        inferred_klass = globals->geos_line_string;
         break;
       case GEOS_LINEARRING:
-        klass_name = "LinearRingImpl";
+        inferred_klass = globals->geos_linear_ring;
         break;
       case GEOS_POLYGON:
-        klass_name = "PolygonImpl";
+        inferred_klass = globals->geos_polygon;
         break;
       case GEOS_MULTIPOINT:
-        klass_name = "MultiPointImpl";
+        inferred_klass = globals->geos_multi_point;
         is_collection = 1;
         break;
       case GEOS_MULTILINESTRING:
-        klass_name = "MultiLineStringImpl";
+        inferred_klass = globals->geos_multi_line_string;
         is_collection = 1;
         break;
       case GEOS_MULTIPOLYGON:
-        klass_name = "MultiPolygonImpl";
+        inferred_klass = globals->geos_multi_polygon;
         is_collection = 1;
         break;
       case GEOS_GEOMETRYCOLLECTION:
-        klass_name = "GeometryCollectionImpl";
+        inferred_klass = globals->geos_geometry_collection;
         is_collection = 1;
         break;
       default:
-        klass_name = "GeometryImpl";
+        inferred_klass = globals->geos_geometry;
         break;
       }
       if (TYPE(klass) == T_ARRAY && is_collection) {
         klasses = klass;
       }
-      klass = rb_const_get_at(RGEO_GLOBALS_FROM_FACTORY(factory)->geos_module, rb_intern(klass_name));
+      klass = inferred_klass;
     }
     RGeo_GeometryData* data = ALLOC(RGeo_GeometryData);
     if (data) {
       if (geom) {
-        GEOSSetSRID_r(RGEO_CONTEXT_FROM_FACTORY(factory), geom, RGEO_FACTORY_DATA_PTR(factory)->srid);
+        GEOSSetSRID_r(factory_context, geom, factory_data->srid);
       }
       data->geom = geom;
+      data->geos_context = factory_context;
       data->factory = factory;
       data->klasses = klasses;
       result = Data_Wrap_Struct(klass, mark_geometry_func, destroy_geometry_func, data);
@@ -311,7 +320,7 @@ VALUE rgeo_wrap_geos_geometry_clone(VALUE factory, const GEOSGeometry* geom, VAL
 {
   VALUE result = Qnil;
   if (geom) {
-    GEOSGeometry* clone_geom = GEOSGeom_clone_r(RGEO_CONTEXT_FROM_FACTORY(factory), geom);
+    GEOSGeometry* clone_geom = GEOSGeom_clone_r(RGEO_FACTORY_DATA_PTR(factory)->geos_context, geom);
     if (clone_geom) {
       result = rgeo_wrap_geos_geometry(factory, clone_geom, klass);
     }
@@ -322,10 +331,16 @@ VALUE rgeo_wrap_geos_geometry_clone(VALUE factory, const GEOSGeometry* geom, VAL
 
 const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALUE type)
 {
-  VALUE object = rb_funcall(RGEO_GLOBALS_FROM_FACTORY(factory)->features_module, rb_intern("cast"), 3, obj, factory, type);
+  VALUE object;
+  if (NIL_P(type) && RGEO_GEOMETRY_DATA_PTR(obj)->factory == factory) {
+    object = obj;
+  }
+  else {
+    object = rb_funcall(RGEO_FACTORY_DATA_PTR(factory)->globals->feature_module, rb_intern("cast"), 3, obj, factory, type);
+  }
   const GEOSGeometry* geom = NULL;
   if (!NIL_P(object)) {
-    geom = RGEO_GET_GEOS_GEOMETRY(object);
+    geom = RGEO_GEOMETRY_DATA_PTR(object)->geom;
   }
   return geom;
 }
@@ -336,19 +351,21 @@ GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, V
   if (klasses) {
     *klasses = Qnil;
   }
-  VALUE object = rb_funcall(RGEO_GLOBALS_FROM_FACTORY(factory)->features_module, rb_intern("cast"), 5, obj, factory, type, ID2SYM(rb_intern("force_new")), ID2SYM(rb_intern("keep_subtype")));
+  VALUE object = rb_funcall(RGEO_FACTORY_DATA_PTR(factory)->globals->feature_module, rb_intern("cast"), 5, obj, factory, type, ID2SYM(rb_intern("force_new")), ID2SYM(rb_intern("keep_subtype")));
   GEOSGeometry* geom = NULL;
   if (!NIL_P(object)) {
-    geom = RGEO_GEOMETRY_DATA_PTR(object)->geom;
+    RGeo_GeometryData* object_data = RGEO_GEOMETRY_DATA_PTR(object);
+    geom = object_data->geom;
     if (klasses) {
-      *klasses = RGEO_KLASSES_FROM_GEOMETRY(object);
+      *klasses = object_data->klasses;
       if (NIL_P(*klasses)) {
         *klasses = CLASS_OF(object);
       }
     }
-    RGEO_GEOMETRY_DATA_PTR(object)->geom = NULL;
-    RGEO_GEOMETRY_DATA_PTR(object)->factory = Qnil;
-    RGEO_GEOMETRY_DATA_PTR(object)->klasses = Qnil;
+    object_data->geom = NULL;
+    object_data->geos_context = NULL;
+    object_data->factory = Qnil;
+    object_data->klasses = Qnil;
   }
   return geom;
 }
@@ -362,7 +379,7 @@ char rgeo_is_geos_object(VALUE obj)
 
 const GEOSGeometry* rgeo_get_geos_geometry_safe(VALUE obj)
 {
-  return (TYPE(obj) == T_DATA && RDATA(obj)->dfree == (RUBY_DATA_FUNC)destroy_geometry_func) ? RGEO_GET_GEOS_GEOMETRY(obj) : NULL;
+  return (TYPE(obj) == T_DATA && RDATA(obj)->dfree == (RUBY_DATA_FUNC)destroy_geometry_func) ? (const GEOSGeometry*)(RGEO_GEOMETRY_DATA_PTR(obj)->geom) : NULL;
 }
 
 
@@ -440,7 +457,7 @@ VALUE rgeo_geos_klasses_and_factories_eql(VALUE obj1, VALUE obj2)
     result = Qfalse;
   }
   else {
-    result = rb_funcall(RGEO_FACTORY_FROM_GEOMETRY(obj1), rb_intern("eql?"), 1, RGEO_FACTORY_FROM_GEOMETRY(obj2));
+    result = rb_funcall(RGEO_GEOMETRY_DATA_PTR(obj1)->factory, rb_intern("eql?"), 1, RGEO_GEOMETRY_DATA_PTR(obj2)->factory);
   }
   return result;
 }

data/ext/geos_c_impl/factory.h

@@ -44,20 +44,44 @@
 RGEO_BEGIN_C
 
 
-// Per-interpreter globals
-
+/*
+  Per-interpreter globals.
+  Most of these are cached references to commonly used classes and modules
+  so we don't have to do a lot of constant lookups.
+*/
 typedef struct {
-  VALUE features_module;
+  VALUE feature_module;
+  VALUE feature_geometry;
+  VALUE feature_point;
+  VALUE feature_line_string;
+  VALUE feature_linear_ring;
+  VALUE feature_line;
+  VALUE feature_polygon;
+  VALUE feature_geometry_collection;
+  VALUE feature_multi_point;
+  VALUE feature_multi_line_string;
+  VALUE feature_multi_polygon;
   VALUE geos_module;
+  VALUE geos_geometry;
+  VALUE geos_point;
+  VALUE geos_line_string;
+  VALUE geos_linear_ring;
+  VALUE geos_line;
+  VALUE geos_polygon;
+  VALUE geos_geometry_collection;
+  VALUE geos_multi_point;
+  VALUE geos_multi_line_string;
+  VALUE geos_multi_polygon;
 } RGeo_Globals;
 
 
-// Wrapped structure for Factory objects.
-// A factory encapsulates the GEOS context, and GEOS serializer settings.
-// It also stores the SRID for all geometries created by this factory,
-// and the resolution for buffers created for this factory's geometries.
-// Finally, it provides easy access to the globals.
-
+/*
+  Wrapped structure for Factory objects.
+  A factory encapsulates the GEOS context, and GEOS serializer settings.
+  It also stores the SRID for all geometries created by this factory,
+  and the resolution for buffers created for this factory's geometries.
+  Finally, it provides easy access to the globals.
+*/
 typedef struct {
   RGeo_Globals* globals;
   GEOSContextHandle_t geos_context;
@@ -76,20 +100,30 @@ typedef struct {
 #define RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M 6
 
 
-// Wrapped structure for Geometry objects.
-// Includes a handle to the underlying GEOS geometry itself (which could
-// be null for an uninitialized geometry).
-// It also provides a handle to the factory that created this geometry.
-// The klasses object is used by geometry collections. Its value is
-// generally an array of the ruby classes for the colletion's elements,
-// so that we can reproduce the exact class for those elements in cases
-// where the class cannot be inferred directly from the GEOS type (as
-// in Line objects, which have no GEOS type). Any array element, or the
-// array itself, could be Qnil, indicating fall back to the default
-// inferred from the GEOS type.
-
+/*
+  Wrapped structure for Geometry objects.
+  Includes a handle to the underlying GEOS geometry itself (which could
+  be null for an uninitialized geometry).
+  It also provides a handle to the factory that created this geometry.
+  
+  The klasses object is used by geometry collections. Its value is
+  generally an array of the ruby classes for the colletion's elements,
+  so that we can reproduce the exact class for those elements in cases
+  where the class cannot be inferred directly from the GEOS type (as
+  in Line objects, which have no GEOS type). Any array element, or the
+  array itself, could be Qnil, indicating fall back to the default
+  inferred from the GEOS type.
+  
+  The GEOS context handle is also included here. Ideally, it would be
+  available by following the factory reference and getting it from the
+  factory data. However, one use case is in the destroy_geometry_func
+  in factory.c, and Rubinius 1.1.1 seems to crash when you try to
+  evaluate a DATA_PTR from that function, so we copy the context handle
+  here so the destroy_geometry_func can get to it.
+*/
 typedef struct {
   GEOSGeometry* geom;
+  GEOSContextHandle_t geos_context;
   VALUE factory;
   VALUE klasses;
 } RGeo_GeometryData;
@@ -101,30 +135,6 @@ typedef struct {
 // Returns the RGeo_GeometryData* given a ruby Geometry object
 #define RGEO_GEOMETRY_DATA_PTR(geometry) ((RGeo_GeometryData*)DATA_PTR(geometry))
 
-// Returns a pointer to the globals given a ruby Factory object
-#define RGEO_GLOBALS_FROM_FACTORY(factory) (RGEO_FACTORY_DATA_PTR(factory)->globals)
-
-// Returns the GEOS context handle given a ruby Factory object
-#define RGEO_CONTEXT_FROM_FACTORY(factory) (RGEO_FACTORY_DATA_PTR(factory)->geos_context)
-
-// Returns the ruby Factory object given a ruby Geometry object
-#define RGEO_FACTORY_FROM_GEOMETRY(geometry) (RGEO_GEOMETRY_DATA_PTR(geometry)->factory)
-
-// Returns the klasses object given a ruby Geometry object
-#define RGEO_KLASSES_FROM_GEOMETRY(geometry) (RGEO_GEOMETRY_DATA_PTR(geometry)->klasses)
-
-// Returns the RGeo_FactoryData* given a ruby Geometry object
-#define RGEO_FACTORY_DATA_FROM_GEOMETRY(geometry) RGEO_FACTORY_DATA_PTR(RGEO_FACTORY_FROM_GEOMETRY(geometry))
-
-// Returns the GEOS geometry handle given a ruby Geometry object
-#define RGEO_GET_GEOS_GEOMETRY(geometry) ((const GEOSGeometry*)(RGEO_GEOMETRY_DATA_PTR(geometry)->geom))
-
-// Returns the GEOS context handle given a ruby Geometry object
-#define RGEO_CONTEXT_FROM_GEOMETRY(geometry) RGEO_CONTEXT_FROM_FACTORY(RGEO_FACTORY_FROM_GEOMETRY(geometry))
-
-// Returns a pointer to the globals given a ruby Geometry object
-#define RGEO_GLOBALS_FROM_GEOMETRY(geometry) RGEO_GLOBALS_FROM_FACTORY(RGEO_FACTORY_FROM_GEOMETRY(geometry))
-
 
 /*
   Initializes the factory module. This should be called first in the