rgeo 0.1.18 → 0.1.19

data/History.rdoc

@@ -1,3 +1,14 @@
+=== 0.1.19 / 2010-11-23
+
+* The GEOS implementation now supports ZM (4-dimensional data), via a wrapper since the underlying GEOS library doesn't support 4d data natively.
+* Added a BoundingBox tool to the Cartesian module.
+* Fleshed out a few more methods of SimpleCartesian and SimpleSpherical.
+* The simple Cartesian point implementation included a bit more leakage from the Geography implementations (pole equivalence, lat/lon methods). Fixed.
+* Under certain circumstances, collections and polygons using GEOS could lose their Z or M coordinates. Fixed.
+* There were some cases when implementations based on ImplHelpers were pulling in the wrong methods. Fixed.
+* Taking the envelope of an empty GEOS collection yielded an illegal object that could cause a crash. Fixed. It now yields an empty collection.
+* Taking the boundary of an empty GEOS collection yielded nil. Fixed. It now yields an empty collection.
+
 === 0.1.18 / 2010-11-22
 
 * API CHANGE: GeoJSON defaults to no JSON parser rather than to the JSON library. GeoJSON also fails better when attempting to use a JSON parser that isn't installed.

data/README.rdoc

@@ -5,7 +5,7 @@ RGeo is a spatial data library for Ruby.
 It provides an implementation of the Open Geospatial Consortium's Simple
 Features Specification, used by most standard spatial/geographic data
 storage systems such as PostGIS. It also provides a suite of useful tools
-for writing location-based applications using Ruby-based frameworks such
+for writing location-aware applications using Ruby-based frameworks such
 as Ruby On Rails.
 
 IMPORTANT: RGeo is currently under development, and we consider it to be
@@ -16,10 +16,10 @@ use of RGeo in production.
 
 === Summary
 
-RGeo is a core component for writing location-based applications in the
+RGeo is a core component for writing location-aware applications in the
 Ruby programming language. It provides the basic tools for modeling
-location data and communicating with geolocation-aware storage systems
-and location-based services.
+location data and communicating with location-aware storage systems
+and services.
 
 Use RGeo to:
 
@@ -35,8 +35,7 @@ Use RGeo to:
   location-based web services such as SimpleGeo.
 * Read legacy GIS data from ESRI shapefiles.
 * Extend Ruby On Rails to handle location data in a web application.
-* Write spatial applications following the latest open standards from
-  the Open Geospatial Consortium.
+* Follow the latest standards from the Open Geospatial Consortium.
 
 === Requirements
 
@@ -44,7 +43,7 @@ RGeo has the following prerequisites:
 
 * Ruby 1.8.7 or later. Ruby 1.9.2 or later preferred.
   Rubinius and JRuby are not yet supported.
-* GEOS 3.2 or later highly recommended. Some functions will not be
+* GEOS 3.2 or later is highly recommended. Some functions will not be
   available without it. This C/C++ library may be available via your
   operating system's package manager, or you can download it from
   http://geos.osgeo.org/
@@ -52,7 +51,7 @@ RGeo has the following prerequisites:
   install the "json" gem. Ruby 1.9 has JSON support in its standard
   library and does not require the gem.
 * If you are using the shapefile reader, you should install the "dbf"
-  gem for access to shape attributes.
+  gem version 1.5.2 or later, which is required to read the attributes.
 * The ActiveRecord adapters for MySQL Spatial, PostGIS, and SpatiaLite
   require ActiveRecord 3.0.3 or later, Arel 2.0 or later, and the
   corresponding database driver gems (e.g. "mysql" or "mysql2").
@@ -78,33 +77,21 @@ the switches interpreted by the gem command. For example:
 
  gem install rgeo -- --with-geos-dir=/path/to/my/geos/installation
 
-=== Known issues
-
-* Some planned and documented functionality on the SimpleCartesian and
-  SimpleSpherical data implementations is not yet implemented.
-* Reading of shapefile attributes is dependent on the "dbf" gem.
-  Unfortunately, the current version of dbf, 1.5.0, has a hard dependency
-  on ActiveSupport 3.0.1, which renders it incompatible with the
-  ActiveRecord adapters, which require at least ActiveRecord 3.0.3
-  (not to mention also rendering it incompatible with Rails 3.0.3...)
-  I have filed a bug report with dbf to try to get this resolved.
-
 === To-do items
 
-This is our potential feature roadmap.
+This is our planned feature roadmap, in rough priority order.
 
+* Projection subsystem, and support for arbitrary projections in the
+  geography module, utilizing proj4.
 * SpatiaLite and PostGIS adapters for ActiveRecord. (We already have an
   adapter for MySQL Spatial.)
+* Integration with certain third-party services such as SimpleGeo.
 * Support for bbox and crs elements of GeoJSON.
-* Support for writing shapefiles. (Reading is now implemented.)
-* Projection subsystem, and support for arbitrary projections in the
-  geography module, utilizing proj4.
-* Geography implementation utilizing ellipsoidal geometry, probably
-  utilizing geographiclib.
-* Integration with other third-party formats and services, potentially
-  including SimpleGeo, GeoRSS, KML.
-* JRuby support via JTS integration.
+* Ellipsoidal geography implementation, probably utilizing geographiclib.
 * Rubinius support for GEOS integration.
+* JRuby support via JTS integration.
+* Support for writing shapefiles. (Reading is already implemented.)
+* Read and write other formats such as GeoRSS and KML.
 
 === Development and support
 
@@ -128,8 +115,8 @@ projects can be found on OSGeo's web site (http://www.osgeo.org/).
 
 The ActiveRecord adapters owe some debt to the spatial_adapter plugin
 (http://github.com/fragility/spatial_adapter). We made a few different
-design decisions for RGeo, but studying the spatial_adapter source gave us
-a head start on our implementation.
+design decisions for RGeo, but studying the spatial_adapter source gave
+us a head start on our implementation.
 
 Although we don't use shapelib (http://shapelib.maptools.org/) to read
 ESRI shapefiles, we did borrow a bunch of their test cases.

data/Version

@@ -1 +1 @@
-0.1.18
+0.1.19

data/ext/geos_c_impl/factory.c

@@ -121,12 +121,11 @@ static void destroy_globals_func(RGeo_Globals* data)
 }
 
 
-// Mark function for globals data. This marks the default factory held
-// by the globals so it doesn't get collected.
+// Mark function for globals data. This should mark any globals that
+// need to be held through garbage collection (none at the moment.)
 
 static void mark_globals_func(RGeo_Globals* data)
 {
-  rb_gc_mark(data->default_factory);
 }
 
 
@@ -225,7 +224,6 @@ RGeo_Globals* rgeo_init_geos_factory()
   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, "Features");
-  globals->default_factory = Qnil;
   
   // Add C methods to the factory.
   VALUE geos_factory_class = rb_const_get_at(globals->geos_module, rb_intern("Factory"));
@@ -241,9 +239,6 @@ RGeo_Globals* rgeo_init_geos_factory()
   VALUE wrapped_globals = Data_Wrap_Struct(rb_cObject, mark_globals_func, destroy_globals_func, globals);
   rb_define_const(geos_factory_class, "INTERNAL_CGLOBALS", wrapped_globals);
   
-  // Default factory used internally.
-  globals->default_factory = rb_funcall(geos_factory_class, rb_intern("create"), 0);
-  
   return globals;
 }
 
@@ -336,12 +331,12 @@ const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALU
 }
 
 
-GEOSGeometry* rgeo_convert_to_detached_geos_geometry(RGeo_Globals* globals, VALUE obj, VALUE type, VALUE* klasses)
+GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, VALUE type, VALUE* klasses)
 {
   if (klasses) {
     *klasses = Qnil;
   }
-  VALUE object = rb_funcall(globals->features_module, rb_intern("cast"), 5, obj, globals->default_factory, type, ID2SYM(rb_intern("force_new")), ID2SYM(rb_intern("keep_subtype")));
+  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")));
   GEOSGeometry* geom = NULL;
   if (!NIL_P(object)) {
     geom = RGEO_GEOMETRY_DATA_PTR(object)->geom;

data/ext/geos_c_impl/factory.h

@@ -47,7 +47,6 @@ RGEO_BEGIN_C
 // Per-interpreter globals
 
 typedef struct {
-  VALUE default_factory;
   VALUE features_module;
   VALUE geos_module;
 } RGeo_Globals;
@@ -164,21 +163,22 @@ 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);
 
 /*
-  Gets a GEOS geometry for a given ruby Geometry object. If the given
-  ruby object is not a GEOS geometry implementation, it is converted to a
-  GEOS implementation first. You may also optionally cast it to a type,
+  Gets a GEOS geometry for a given ruby Geometry object. You must provide
+  a GEOS factory for the geometry; the object is cast to that factory if
+  it is not already of it. You may also optionally cast it to a type,
   specified by an appropriate feature module. Passing Qnil for the type
   disables this auto-cast. The returned GEOS geometry is owned by the
-  caller-- that is, if the original ruby object is a GEOS implementation,
-  the returned GEOS geometry is a clone of the original.
-  If the klasses parameters is not NULL, its referent is set to the
+  caller-- that is, if the original ruby object is already of the desired
+  factory, the returned GEOS geometry is a clone of the original.
+  
+  If the klasses parameter is not NULL, its referent is set to the
   klasses saved in the original ruby Geometry object (if any), or else to
   the class of the converted GEOS object. This is so that you can use the
   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.
 */
-GEOSGeometry* rgeo_convert_to_detached_geos_geometry(RGeo_Globals* globals, VALUE obj, VALUE type, VALUE* klasses);
+GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, VALUE type, VALUE* klasses);
 
 /*
   Returns 1 if the given ruby object is a GEOS Geometry implementation,

data/ext/geos_c_impl/geometry.c

@@ -161,7 +161,18 @@ static VALUE method_geometry_envelope(VALUE self)
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
   if (self_geom) {
-    result = rgeo_wrap_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), GEOSEnvelope_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom), Qnil);
+    GEOSGeometry* envelope = GEOSEnvelope_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom);
+    // GEOS returns an "empty" point for an empty collection's envelope.
+    // We don't allow that type, so we replace it with an empty collection.
+    if (!envelope ||
+        GEOSGeomTypeId_r(RGEO_CONTEXT_FROM_GEOMETRY(self), envelope) == GEOS_POINT &&
+        GEOSGetNumCoordinates_r(RGEO_CONTEXT_FROM_GEOMETRY(self), envelope) == 0) {
+      if (envelope) {
+        GEOSGeom_destroy_r(RGEO_CONTEXT_FROM_GEOMETRY(self), envelope);
+      }
+      envelope = GEOSGeom_createCollection_r(RGEO_CONTEXT_FROM_GEOMETRY(self), GEOS_GEOMETRYCOLLECTION, NULL, 0);
+    }
+    result = rgeo_wrap_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), envelope, Qnil);
   }
   return result;
 }
@@ -172,7 +183,13 @@ static VALUE method_geometry_boundary(VALUE self)
   VALUE result = Qnil;
   const GEOSGeometry* self_geom = RGEO_GET_GEOS_GEOMETRY(self);
   if (self_geom) {
-    result = rgeo_wrap_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), GEOSBoundary_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom), Qnil);
+    GEOSGeometry* boundary = GEOSBoundary_r(RGEO_CONTEXT_FROM_GEOMETRY(self), self_geom);
+    // GEOS returns NULL for the boundary of an empty collection.
+    // Replace that with an empty collection.
+    if (!boundary) {
+      boundary = GEOSGeom_createCollection_r(RGEO_CONTEXT_FROM_GEOMETRY(self), GEOS_GEOMETRYCOLLECTION, NULL, 0);
+    }
+    result = rgeo_wrap_geos_geometry(RGEO_FACTORY_FROM_GEOMETRY(self), boundary, Qnil);
   }
   return result;
 }

data/ext/geos_c_impl/geometry_collection.c

@@ -80,7 +80,7 @@ static VALUE create_geometry_collection(VALUE module, int type, VALUE factory, V
       break;
     }
     for (i=0; i<len; ++i) {
-      GEOSGeometry* geom = rgeo_convert_to_detached_geos_geometry(RGEO_GLOBALS_FROM_FACTORY(factory), rb_ary_entry(array, i), cast_type, &klass);
+      GEOSGeometry* geom = rgeo_convert_to_detached_geos_geometry(rb_ary_entry(array, i), factory, cast_type, &klass);
       if (!geom) {
         break;
       }

data/ext/geos_c_impl/polygon.c

@@ -165,7 +165,7 @@ static VALUE cmethod_create(VALUE module, VALUE factory, VALUE exterior, VALUE i
 {
   Check_Type(interior_array, T_ARRAY);
   VALUE linear_ring_type = rb_const_get_at(RGEO_GLOBALS_FROM_FACTORY(factory)->features_module, rb_intern("LinearRing"));
-  GEOSGeometry* exterior_geom = rgeo_convert_to_detached_geos_geometry(RGEO_GLOBALS_FROM_FACTORY(factory), exterior, linear_ring_type, NULL);
+  GEOSGeometry* exterior_geom = rgeo_convert_to_detached_geos_geometry(exterior, factory, linear_ring_type, NULL);
   if (exterior_geom) {
     unsigned int len = (unsigned int)RARRAY_LEN(interior_array);
     GEOSGeometry** interior_geoms = ALLOC_N(GEOSGeometry*, len == 0 ? 1 : len);
@@ -173,7 +173,7 @@ static VALUE cmethod_create(VALUE module, VALUE factory, VALUE exterior, VALUE i
       unsigned int actual_len = 0;
       unsigned int i;
       for (i=0; i<len; ++i) {
-        GEOSGeometry* interior_geom = rgeo_convert_to_detached_geos_geometry(RGEO_GLOBALS_FROM_FACTORY(factory), rb_ary_entry(interior_array, i), linear_ring_type, NULL);
+        GEOSGeometry* 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;
         }

data/lib/active_record/connection_adapters/mysql2spatial_adapter.rb

@@ -38,12 +38,14 @@ require 'rgeo/active_record/mysql_common'
 require 'active_record/connection_adapters/mysql2_adapter'
 
 
-module ActiveRecord  # :nodoc:
+module ActiveRecord
   
-  class Base  # :nodoc:
+  class Base
     
     
-    def self.mysql2spatial_connection(config_)  # :nodoc:
+    # Create a mysql2spatial connection adapter
+    
+    def self.mysql2spatial_connection(config_)
       config_[:username] = 'root' if config_[:username].nil?
       if ::Mysql2::Client.const_defined?(:FOUND_ROWS)
         config_[:flags] = ::Mysql2::Client::FOUND_ROWS
@@ -57,12 +59,12 @@ module ActiveRecord  # :nodoc:
   end
   
   
-  module ConnectionAdapters
+  module ConnectionAdapters  # :nodoc:
     
-    class Mysql2SpatialAdapter < Mysql2Adapter
+    class Mysql2SpatialAdapter < Mysql2Adapter  # :nodoc:
       
       
-      class SpatialColumn < ConnectionAdapters::Mysql2Column
+      class SpatialColumn < ConnectionAdapters::Mysql2Column  # :nodoc:
         
         include ::RGeo::ActiveRecord::MysqlCommon::ColumnMethods
         

data/lib/active_record/connection_adapters/mysqlspatial_adapter.rb

@@ -38,12 +38,14 @@ require 'rgeo/active_record/mysql_common'
 require 'active_record/connection_adapters/mysql_adapter'
 
 
-module ActiveRecord  # :nodoc:
+module ActiveRecord
   
-  class Base  # :nodoc:
+  class Base
     
     
-    def self.mysqlspatial_connection(config_)  # :nodoc:
+    # Create a mysqlspatial connection adapter
+    
+    def self.mysqlspatial_connection(config_)
       unless defined?(::Mysql)
         begin
           require 'mysql'
@@ -67,12 +69,12 @@ module ActiveRecord  # :nodoc:
   end
   
   
-  module ConnectionAdapters
+  module ConnectionAdapters  # :nodoc:
     
-    class MysqlSpatialAdapter < MysqlAdapter
+    class MysqlSpatialAdapter < MysqlAdapter  # :nodoc:
       
       
-      class SpatialColumn < ConnectionAdapters::MysqlColumn
+      class SpatialColumn < ConnectionAdapters::MysqlColumn  # :nodoc:
         
         include ::RGeo::ActiveRecord::MysqlCommon::ColumnMethods
         

data/lib/rgeo/active_record/arel_modifications.rb

@@ -37,6 +37,8 @@
 require 'arel'
 
 
+# :stopdoc:
+
 module Arel
   
   module Attributes
@@ -71,3 +73,5 @@ module Arel
   end
   
 end
+
+# :startdoc:

data/lib/rgeo/active_record/base_modifications.rb

@@ -37,24 +37,57 @@
 require 'active_record'
 
 
-module ActiveRecord  # :nodoc:
+# RGeo extensions to ActiveRecord are installed when one of the spatial
+# connection adapters is needed. These modifications require ActiveRecord
+# 3.0.3 or later.
+
+module ActiveRecord
+  
+  
+  # RGeo extends ActiveRecord::Base to include the following new class
+  # attributes. These attributes are inherited by subclasses, and can
+  # be overridden in subclasses.
+  # 
+  # === ActiveRecord::Base::rgeo_factory_generator
+  # 
+  # The value of this attribute is a RGeo::Features::FactoryGenerator
+  # that is used to generate the proper factory when loading geometry
+  # objects from the database. For example, if the data being loaded
+  # has M but not Z coordinates, and an embedded SRID, then this
+  # FactoryGenerator is called with the appropriate configuration to
+  # obtain a factory with those properties. This factory is the one
+  # associated with the actual geometry properties of the ActiveRecord
+  # object.
+  # 
+  # === ActiveRecord::Base::rgeo_default_factory
+  # 
+  # The default factory used to load RGeo geometry objects from the
+  # database. This is used when there is no rgeo_factory_generator.
   
-  class Base  # :nodoc:
+  class Base
+    
     
     self.attribute_types_cached_by_default << :geometry
     
+    
     class_attribute :rgeo_default_factory, :instance_writer => false
     self.rgeo_default_factory = nil
     
     class_attribute :rgeo_factory_generator, :instance_writer => false
     self.rgeo_factory_generator = nil
     
+    
+    # This is a convenient way to set the rgeo_factory_generator by
+    # passing a block.
+    
     def self.to_generate_rgeo_factory(&block_)
       self.rgeo_factory_generator = block_
     end
     
+    
     class << self
       
+      # :stopdoc:
       alias_method :columns_without_rgeo_modification, :columns
       def columns
         unless defined?(@columns) && @columns
@@ -64,9 +97,11 @@ module ActiveRecord  # :nodoc:
         end
         @columns
       end
+      # :startdoc:
       
     end
     
   end
   
+  
 end

data/lib/rgeo/active_record/mysql_common.rb

@@ -42,10 +42,10 @@ require 'rgeo/active_record/common'
 
 module RGeo
   
-  module ActiveRecord
+  module ActiveRecord  # :nodoc:
     
     
-    module MysqlCommon
+    module MysqlCommon  # :nodoc:
       
       
       module AdapterMethods  # :nodoc:

data/lib/rgeo/cartesian.rb

@@ -41,28 +41,11 @@ require 'rgeo'
 module RGeo
   
   
-  # The Cartesian module provides a simple spatial implementation using
-  # the Cartesian coordinate system. This is the default implementation
-  # used by RGeo if no full-featured implementation, such as Geos, is
-  # available.
-  # 
-  # The Cartesian implementation can handle all the SFS 1.1 types, and
-  # provides extensions for Z and M coordinates. It also provides WKT
-  # and WKB serialization using the WKRep module.
-  # 
-  # However, the Cartesian implementation does not implement many of
-  # the more advanced geometric operations. Limitations include:
-  # * relational operators such as Features::Geometry#intersects? are
-  #   not implemented for most types.
-  # * relational constructors such as Features::Geometry#union are
-  #   not implemented for most types.
-  # * buffer, boundary, and convex hull calculation are not implemented
-  #   for most types.
-  # * distance and area calculation are not implemented for most types,
-  #   though length for LineStrings is implemented.
-  # * equality and simplicity evaluation are implemented for some types
-  #   but not all types.
-  # * assertions for polygons and multipolygons are not implemented.
+  # The Cartesian module is a gateway to implementations that use the
+  # Cartesian (i.e. flat) coordinate system. It provides convenient
+  # access to Cartesian factories such as the Geos implementation and
+  # the simple Cartesian implementation. It also provides a namespace
+  # for Cartesian-specific analysis tools.
   
   module Cartesian
   end
@@ -82,4 +65,5 @@ require 'rgeo/cartesian/feature_methods'
 require 'rgeo/cartesian/feature_classes'
 require 'rgeo/cartesian/factory'
 require 'rgeo/cartesian/interface'
+require 'rgeo/cartesian/bounding_box'
 require 'rgeo/cartesian/analysis'