rgeo 2.1.0 → 2.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2430c81b8d65c3e98a0e4411c4b10d5b71e6eb1d90ae59bffeab5f71c2da2cb3
-  data.tar.gz: 55aca2dc0b4f7b08641d54b40d8248e594a58574c13690e092dcd8718a392c1c
+  metadata.gz: b93de3431a81612631cfa612d589bc0e1026f16276d3c1e848b71f1a3e682731
+  data.tar.gz: 992a46705454a1fe1c77405e9b6f753739af0c80b9e6f58d8e60da07b75eea93
 SHA512:
-  metadata.gz: 70f91cfbacb9c87fc6aa974eeeb3863452ebe3a041544249e8a9824864352f9f1f32525c6c952a37091b4f632b29269e9249a57098533c9a971c4d79c6406e29
-  data.tar.gz: 708edf08257aa5f3215aeb43fbcfe3aa36afe1950974b9a1120805d0512b6cd2edeaf334baf44f486cbf766cd1faa44b52d084e1ae415dae5d0f5e6014cd5e04
+  metadata.gz: aca5ecae4e1c3ee2d022591ccf612aae3e4f8539543cc740ba3875b15ae156da6e1e13180a305e0c2a41a9bcf3a60e3eafb5c87eb737f95ef194e08fe66c39f9
+  data.tar.gz: 94ae519f52c0a6deada3e560722256e99fc482528be8ceea67496cf0dbc7488da9bf643ab2905a28294aaa68ac3f532e913c3afb7fea2877b438ecf282911153

data/README.md

@@ -0,0 +1,160 @@
+## 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)
+
+RGeo is a geospatial data library for Ruby.
+
+:warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning:
+
+This organization is looking for maintainers, see [this issue](https://github.com/rgeo/rgeo/issues/216) for more information.
+
+:warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning::warning:
+
+### Summary
+
+RGeo is a key component for writing location-aware applications in the Ruby
+programming language. At its core is an implementation of the industry
+standard OGC Simple Features Specification, which provides data
+representations of geometric objects such as points, lines, and polygons,
+along with a set of geometric analysis operations. This makes it ideal for
+modeling geolocation data. It also supports a suite of optional add-on modules
+that provide various geolocation-related services.
+
+Use the core **rgeo** gem to:
+
+*   Represent spatial and geolocation data objects such as points, lines, and
+    polygons in your Ruby application.
+*   Perform standard spatial analysis operations such as finding
+    intersections, creating buffers, and computing lengths and areas.
+*   Correctly handle spherical geometry, and compute geographic projections
+    for map display and data analysis.
+*   Read and write location data in the WKT and WKB representations used by
+    spatial databases.
+
+
+### Dependencies
+
+RGeo works with the following Ruby implementations:
+
+*   MRI Ruby 2.3.0 or later.
+*   Partial support for JRuby 9.0 or later. The FFI implementation of GEOS
+    is available (ffi-geos gem required) but CAPI is not.
+*   See earlier versions for support for older ruby versions.
+
+Some features also require the following:
+
+*   GEOS 3.2 or later is highly recommended. (3.3.3 or later preferred.) Some
+    functions will not be available without it. This C/C++ library may be
+    available via your operating system's package manager (`sudo aptitude
+    install libgeos-dev` for debian based Linux distributions, `yum install geos geos-devel` for redhat based Linux distributions), or you can
+    download it from http://trac.osgeo.org/geos
+*   On some platforms, you should install the ffi-geos gem (version 1.2.0 or
+    later recommended.) JRuby requires this gem to link properly with Geos,
+    and Windows builds probably do as well.
+
+### Installation
+
+Install the RGeo gem:
+
+```sh
+gem install rgeo
+```
+
+or include it in your Gemfile:
+
+```ruby
+gem "rgeo"
+```
+
+If you are using proj.4 extensions, include
+[`rgeo-proj4`](https://github.com/rgeo/rgeo-proj4):
+
+```ruby
+gem "rgeo-proj4"
+```
+
+
+### Extensions
+
+The [RGeo organization](https://github.com/rgeo) provides several gems that extend RGeo:
+
+#### [`rgeo-proj4`](https://github.com/rgeo/rgeo-proj4)
+
+Proj4 extensions
+
+#### [`rgeo-geojson`](https://github.com/rgeo/rgeo-geojson)
+
+Read and write GeoJSON
+
+#### [`rgeo-shapefile`](https://github.com/rgeo/rgeo-shapefile)
+
+Read ESRI shapefiles
+
+#### [`activerecord-postgis-adapter`](https://github.com/rgeo/activerecord-postgis-adapter)
+
+ActiveRecord connection adapter for PostGIS, based on postgresql (pg gem)
+
+#### [`activerecord-mysql2spatial-adapter`](https://github.com/rgeo/activerecord-mysql2spatial-adapter)
+
+ActiveRecord connection adapter for MySQL Spatial Extensions, based on mysql2
+
+#### [`activerecord-spatialite-adapter`](https://github.com/rgeo/activerecord-spatialite-adapter)
+
+ActiveRecord connection adapter for SpatiaLite, based on sqlite3 (*not maintained)
+
+
+### Development and support
+
+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).
+
+Support may be available on the
+[rgeo-users google group](https://groups.google.com/forum/#!forum/rgeo-users)
+or on [Stack Overflow](https://stackoverflow.com/questions/tagged/rgeo).
+
+### Documentation
+
+You can see more in-depth documentation in the `doc` folder. Factories and
+methods are documented inline, you should consider checking
+https://rubydoc.info/gems/rgeo with the version you are currently using. Or
+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)
+- [Examples](https://github.com/rgeo/rgeo/blob/master/doc/Examples.md)
+- [Who uses `rgeo`?](https://github.com/rgeo/rgeo/blob/master/doc/Gallery.md)
+
+You can see an exhaustive and up to date list at https://rubydoc.info/gems/rgeo/index.
+### Acknowledgments
+
+[Daniel Azuma](http://www.daniel-azuma.com) created RGeo.
+[Tee Parham](http://twitter.com/teeparham) is a former maintainer.
+[Keith Doggett](http://www.github.com/keithdoggett), [Ulysse Buonomo](http://www.github.com/BuonOmo) are current maintainers.
+
+Development is supported by:
+
+- [Klaxit](https://www.github.com/klaxit)
+- Goldfish Ads
+
+RGeo calls the GEOS library to handle most Cartesian geometric calculations,
+and the Proj4 library to handle projections and coordinate transformations.
+These libraries are maintained by the Open Source Geospatial Foundation; more
+information is available on [OSGeo's web site](http://www.osgeo.org).
+
+JRuby support is made possible by the ffi-geos (and upcoming ffi-proj4) gems,
+by [J Smith](https://github.com/dark-panda).
+
+
+### License
+
+Copyright (c) Daniel Azuma, Tee Parham
+
+[License](https://github.com/rgeo/rgeo/blob/master/LICENSE.txt)

data/ext/geos_c_impl/analysis.c

@@ -0,0 +1,78 @@
+/*
+  Analysis methos for GEOS wrapper
+*/
+
+#include "preface.h"
+
+#ifdef RGEO_GEOS_SUPPORTED
+
+#include <ruby.h>
+#include <geos_c.h>
+
+#include "analysis.h"
+#include "factory.h"
+#include "errors.h"
+
+RGEO_BEGIN_C
+
+/*
+ * call-seq:
+ *   RGeo::Geos::Analysis.ccw? -> true or false
+ *
+ * Checks direction for a ring, returns +true+ if counter-clockwise, +false+
+ * otherwise.
+ */
+#ifdef RGEO_GEOS_SUPPORTS_ISCCW
+VALUE rgeo_geos_analysis_ccw_p(VALUE self, VALUE ring)
+{
+
+  const RGeo_GeometryData* ring_data;
+  const GEOSCoordSequence* coord_seq;
+  char is_ccw;
+
+  rgeo_check_geos_object(ring);
+
+  ring_data = RGEO_GEOMETRY_DATA_PTR(ring);
+
+  coord_seq = GEOSGeom_getCoordSeq_r(ring_data->geos_context, ring_data->geom);
+  if (!coord_seq) { rb_raise(geos_error, "Could not retrieve CoordSeq from given ring."); }
+  if (!GEOSCoordSeq_isCCW_r(ring_data->geos_context, coord_seq, &is_ccw)) {
+    rb_raise(geos_error, "Could not determine if the CoordSeq is CCW.");
+  }
+
+  return is_ccw ? Qtrue : Qfalse;
+};
+#endif // RGEO_GEOS_SUPPORTS_ISCCW
+
+
+/**
+ * call-seq:
+ *   RGeo::Geos::Analysis.ccw_supported? -> true or false 
+ * 
+ * Checks if the RGEO_GEOS_SUPPORTS_ISCCW macro is defined, returns +true+
+ * if it is, +false+ otherwise
+ */
+VALUE rgeo_geos_analysis_supports_ccw(VALUE self)
+{
+  #ifdef RGEO_GEOS_SUPPORTS_ISCCW
+    return Qtrue;
+  #else
+    return Qfalse;
+  #endif
+}
+
+
+void rgeo_init_geos_analysis(RGeo_Globals* globals)
+{
+  VALUE geos_analysis_module;
+
+  geos_analysis_module = rb_define_module_under(globals->geos_module, "Analysis");
+  rb_define_singleton_method(geos_analysis_module, "ccw_supported?", rgeo_geos_analysis_supports_ccw, 0);
+  #ifdef RGEO_GEOS_SUPPORTS_ISCCW
+  rb_define_singleton_method(geos_analysis_module, "ccw?", rgeo_geos_analysis_ccw_p, 1);
+  #endif // RGEO_GEOS_SUPPORTS_ISCCW
+}
+
+RGEO_END_C
+
+#endif

data/ext/geos_c_impl/analysis.h

@@ -0,0 +1,42 @@
+/*
+  Analysis methos for GEOS wrapper
+*/
+
+#ifndef RGEO_GEOS_ANALYSIS_INCLUDED
+#define RGEO_GEOS_ANALYSIS_INCLUDED
+
+#include <ruby.h>
+
+#ifdef RGEO_GEOS_SUPPORTED
+
+#include "factory.h"
+
+RGEO_BEGIN_C
+
+/*
+ * call-seq:
+ *   RGeo::Geos::Analysis.ccw? -> true or false
+ *
+ * Checks direction for a ring, returns +true+ if counter-clockwise, +false+
+ * otherwise.
+ */
+#ifdef RGEO_GEOS_SUPPORTS_CCW
+VALUE rgeo_geos_analysis_ccw_p(VALUE self, VALUE ring);
+#endif // RGEO_GEOS_SUPPORTS_CCW
+
+/**
+ * call-seq:
+ *   RGeo::Geos::Analysis.ccw_supported? -> true or false 
+ * 
+ * Checks if the RGEO_GEOS_SUPPORTS_ISCCW macro is defined, returns +true+
+ * if it is, +false+ otherwise
+ */
+VALUE rgeo_geos_analysis_supports_ccw(VALUE self);
+
+void rgeo_init_geos_analysis(RGeo_Globals* globals);
+
+RGEO_END_C
+
+#endif // RGEO_GEOS_SUPPORTED
+
+#endif // RGEO_GEOS_ANALYSIS_INCLUDED

data/ext/geos_c_impl/errors.c

@@ -0,0 +1,35 @@
+
+#ifndef RGEO_GEOS_ERROS_INCLUDED
+#define RGEO_GEOS_ERROS_INCLUDED
+
+#include <ruby.h>
+
+#include "preface.h"
+
+#ifdef RGEO_GEOS_SUPPORTED
+
+#include "errors.h"
+
+RGEO_BEGIN_C
+
+// Any error relative to RGeo.
+VALUE rgeo_error;
+// RGeo error specific to the GEOS implementation.
+VALUE geos_error;
+
+
+void rgeo_init_geos_errors() {
+  VALUE rgeo_module;
+  VALUE error_module;
+
+  rgeo_module = rb_define_module("RGeo");
+  error_module = rb_define_module_under(rgeo_module, "Error");
+  rgeo_error = rb_define_class_under(error_module, "RGeoError", rb_eRuntimeError);
+  geos_error = rb_define_class_under(error_module, "GeosError", rgeo_error);
+}
+
+RGEO_END_C
+
+#endif // RGEO_GEOS_SUPPORTED
+
+#endif // RGEO_GEOS_ERROS_INCLUDED

data/ext/geos_c_impl/errors.h

@@ -0,0 +1,22 @@
+
+#ifndef RGEO_GEOS_ERROS_INCLUDED
+#define RGEO_GEOS_ERROS_INCLUDED
+
+#include <ruby.h>
+
+#ifdef RGEO_GEOS_SUPPORTED
+
+RGEO_BEGIN_C
+
+// Any error relative to RGeo.
+extern VALUE rgeo_error;
+// RGeo error specific to the GEOS implementation.
+extern VALUE geos_error;
+
+void rgeo_init_geos_errors();
+
+RGEO_END_C
+
+#endif // RGEO_GEOS_SUPPORTED
+
+#endif // RGEO_GEOS_ERROS_INCLUDED

data/ext/geos_c_impl/extconf.rb

@@ -31,6 +31,7 @@ else
     have_func("GEOSPreparedContains_r", "geos_c.h")
     have_func("GEOSPreparedDisjoint_r", "geos_c.h")
     have_func("GEOSUnaryUnion_r", "geos_c.h")
+    have_func("GEOSCoordSeq_isCCW_r", "geos_c.h")
     have_func("rb_memhash", "ruby.h")
   end
 

data/ext/geos_c_impl/factory.c

@@ -16,6 +16,7 @@
 #include "line_string.h"
 #include "polygon.h"
 #include "geometry_collection.h"
+#include "errors.h"
 
 RGEO_BEGIN_C
 
@@ -576,10 +577,11 @@ RGeo_Globals* rgeo_init_geos_factory()
   VALUE wrapped_globals;
   VALUE feature_module;
 
+  rgeo_module = rb_define_module("RGeo");
+
   globals = ALLOC(RGeo_Globals);
 
   // Cache some modules so we don't have to look them up by name every time
-  rgeo_module = rb_define_module("RGeo");
   feature_module = rb_define_module_under(rgeo_module, "Feature");
   globals->feature_module = feature_module;
   globals->geos_module = rb_define_module_under(rgeo_module, "Geos");
@@ -771,7 +773,6 @@ 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;
-  const GEOSGeometry* geom;
   RGeo_Globals* globals;
 
   if (NIL_P(type) && TYPE(obj) == T_DATA && RDATA(obj)->dfree == (RUBY_DATA_FUNC)destroy_geometry_func && RGEO_GEOMETRY_DATA_PTR(obj)->factory == factory) {
@@ -781,11 +782,11 @@ const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALU
     globals = RGEO_FACTORY_DATA_PTR(factory)->globals;
     object = rb_funcall(globals->feature_module, globals->id_cast, 3, obj, factory, type);
   }
-  geom = NULL;
-  if (!NIL_P(object)) {
-    geom = RGEO_GEOMETRY_DATA_PTR(object)->geom;
-  }
-  return geom;
+  if (NIL_P(object))
+    return NULL;
+
+  Check_Type(object, T_DATA);
+  return RGEO_GEOMETRY_DATA_PTR(object)->geom;
 }
 
 
@@ -831,6 +832,13 @@ char rgeo_is_geos_object(VALUE obj)
   return (TYPE(obj) == T_DATA && RDATA(obj)->dfree == (RUBY_DATA_FUNC)destroy_geometry_func) ? 1 : 0;
 }
 
+void rgeo_check_geos_object(VALUE obj)
+{
+  if (!rgeo_is_geos_object(obj)) {
+    rb_raise(rgeo_error, "Not a GEOS Geometry object.");
+  }
+}
+
 
 const GEOSGeometry* rgeo_get_geos_geometry_safe(VALUE obj)
 {

data/ext/geos_c_impl/factory.h

@@ -10,7 +10,6 @@
 
 RGEO_BEGIN_C
 
-
 /*
   Per-interpreter globals.
   Most of these are cached references to commonly used classes, modules,
@@ -187,6 +186,11 @@ GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, V
 */
 char rgeo_is_geos_object(VALUE obj);
 
+/*
+  Raises a rgeo error if the object is not a GEOS Geometry implementation.
+*/
+void rgeo_check_geos_object(VALUE obj);
+
 /*
   Gets the underlying GEOS geometry for a given ruby object. Returns NULL
   if the given ruby object is not a GEOS geometry wrapper.

data/ext/geos_c_impl/geometry.c

@@ -1045,12 +1045,13 @@ static VALUE method_geometry_invalid_reason(VALUE self)
   self_geom = self_data->geom;
   if (self_geom) {
     str = GEOSisValidReason_r(self_data->geos_context, self_geom);
-    if (str) {
-      result = rb_str_new2(str);
-    }
-    else {
-      result = rb_str_new2("Exception");
-    }
+    // Per documentation, a valid geometry should give an empty string.
+    // However it seems not to be the case. Hence the comparison against
+    // the string that is really given: `"Valid Geometry"`.
+    // See https://github.com/libgeos/geos/issues/431.
+    if (str) result = (str[0] == '\0' || !strcmp(str, "Valid Geometry")) ? Qnil : rb_str_new2(str);
+    else result = rb_str_new2("Exception");
+    GEOSFree_r(self_data->geos_context, str);
   }
   return result;
 }
@@ -1094,8 +1095,8 @@ void rgeo_init_geos_geometry(RGeo_Globals* globals)
   rb_define_method(geos_geometry_methods, "boundary", method_geometry_boundary, 0);
   rb_define_method(geos_geometry_methods, "_as_text", method_geometry_as_text, 0);
   rb_define_method(geos_geometry_methods, "as_binary", method_geometry_as_binary, 0);
-  rb_define_method(geos_geometry_methods, "is_empty?", method_geometry_is_empty, 0);
-  rb_define_method(geos_geometry_methods, "is_simple?", method_geometry_is_simple, 0);
+  rb_define_method(geos_geometry_methods, "empty?", method_geometry_is_empty, 0);
+  rb_define_method(geos_geometry_methods, "simple?", method_geometry_is_simple, 0);
   rb_define_method(geos_geometry_methods, "equals?", method_geometry_equals, 1);
   rb_define_method(geos_geometry_methods, "==", method_geometry_equals, 1);
   rb_define_method(geos_geometry_methods, "rep_equals?", method_geometry_eql, 1);

data/ext/geos_c_impl/geometry_collection.c

@@ -623,7 +623,7 @@ void rgeo_init_geos_geometry_collection(RGeo_Globals* globals)
   geos_multi_line_string_methods = rb_define_module_under(globals->geos_module, "CAPIMultiLineStringMethods");
   rb_define_method(geos_multi_line_string_methods, "geometry_type", method_multi_line_string_geometry_type, 0);
   rb_define_method(geos_multi_line_string_methods, "length", method_multi_line_string_length, 0);
-  rb_define_method(geos_multi_line_string_methods, "is_closed?", method_multi_line_string_is_closed, 0);
+  rb_define_method(geos_multi_line_string_methods, "closed?", method_multi_line_string_is_closed, 0);
   rb_define_method(geos_multi_line_string_methods, "hash", method_multi_line_string_hash, 0);
   rb_define_method(geos_multi_line_string_methods, "coordinates", method_multi_line_string_coordinates, 0);
 

data/ext/geos_c_impl/line_string.c

@@ -663,8 +663,8 @@ void rgeo_init_geos_line_string(RGeo_Globals* globals)
   rb_define_method(geos_line_string_methods, "end_point", method_line_string_end_point, 0);
   rb_define_method(geos_line_string_methods, "project_point", method_line_string_project_point, 1);
   rb_define_method(geos_line_string_methods, "interpolate_point", method_line_string_interpolate_point, 1);
-  rb_define_method(geos_line_string_methods, "is_closed?", method_line_string_is_closed, 0);
-  rb_define_method(geos_line_string_methods, "is_ring?", method_line_string_is_ring, 0);
+  rb_define_method(geos_line_string_methods, "closed?", method_line_string_is_closed, 0);
+  rb_define_method(geos_line_string_methods, "ring?", method_line_string_is_ring, 0);
   rb_define_method(geos_line_string_methods, "coordinates", method_line_string_coordinates, 0);
 
   // CAPILinearRingMethods module

data/ext/geos_c_impl/main.c

@@ -2,7 +2,6 @@
   Main initializer for GEOS wrapper
 */
 
-
 #include "preface.h"
 
 #ifdef RGEO_GEOS_SUPPORTED
@@ -10,18 +9,20 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "errors.h"
+
 #include "factory.h"
 #include "geometry.h"
 #include "point.h"
 #include "line_string.h"
 #include "polygon.h"
 #include "geometry_collection.h"
+#include "analysis.h"
 
 #endif
 
 RGEO_BEGIN_C
 
-
 void Init_geos_c_impl()
 {
 #ifdef RGEO_GEOS_SUPPORTED
@@ -33,6 +34,8 @@ void Init_geos_c_impl()
   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_errors();
 #endif
 }
 

data/ext/geos_c_impl/preface.h

@@ -21,6 +21,9 @@
 #ifdef HAVE_GEOSUNARYUNION_R
 #define RGEO_GEOS_SUPPORTS_UNARYUNION
 #endif
+#ifdef HAVE_GEOSCOORDSEQ_ISCCW_R
+#define RGEO_GEOS_SUPPORTS_ISCCW
+#endif
 #ifdef HAVE_RB_MEMHASH
 #define RGEO_SUPPORTS_NEW_HASHING
 #endif

data/lib/rgeo/cartesian/analysis.rb

@@ -13,6 +13,28 @@ module RGeo
 
     module Analysis
       class << self
+        # Check orientation of a ring, returns `true` if it is counter-clockwise
+        # and false otherwise.
+        #
+        # If the factory used is GEOS based, use the GEOS implementation to
+        # check that. Otherwise, this methods falls back to `ring_direction`.
+        #
+        # == Note
+        #
+        # This method does not ensure a correct result for an invalid geometry.
+        # You should make sure your ring is valid beforehand using `ring?`
+        # if you are using a LineString, or directly `valid?` for a
+        # `linear_ring?`.
+        # This will be subject to changes in v3.
+        def ccw?(ring)
+          if RGeo::Geos.capi_geos?(ring) && RGeo::Geos::Analysis.ccw_supported?
+            RGeo::Geos::Analysis.ccw?(ring)
+          else
+            RGeo::Cartesian::Analysis.ring_direction(ring) == 1
+          end
+        end
+        alias counter_clockwise? ccw?
+
         # Given a LineString, which must be a ring, determine whether the
         # ring proceeds clockwise or counterclockwise.
         # Returns 1 for counterclockwise, or -1 for clockwise.

data/lib/rgeo/cartesian/feature_methods.rb

@@ -49,7 +49,7 @@ module RGeo
         end
       end
 
-      def is_simple?
+      def simple?
         len = segments.length
         return false if segments.any?(&:degenerate?)
         return true if len == 1
@@ -72,6 +72,11 @@ module RGeo
         true
       end
 
+      def is_simple?
+        warn "The is_simple? method is deprecated, please use the simple? counterpart, will be removed in v3" unless ENV["RGEO_SILENCE_DEPRECATION"]
+        simple?
+      end
+
       def length
         segments.inject(0.0) { |sum, seg| sum + seg.length }
       end

data/lib/rgeo/cartesian.rb

@@ -6,10 +6,10 @@
 # the simple Cartesian implementation. It also provides a namespace
 # for Cartesian-specific analysis tools.
 
-require "rgeo/cartesian/calculations"
-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"
+require_relative "cartesian/calculations"
+require_relative "cartesian/feature_methods"
+require_relative "cartesian/feature_classes"
+require_relative "cartesian/factory"
+require_relative "cartesian/interface"
+require_relative "cartesian/bounding_box"
+require_relative "cartesian/analysis"

data/lib/rgeo/coord_sys.rb

@@ -6,12 +6,12 @@
 #
 # -----------------------------------------------------------------------------
 
-require "rgeo/coord_sys/cs/factories"
-require "rgeo/coord_sys/cs/entities"
-require "rgeo/coord_sys/cs/wkt_parser"
-require "rgeo/coord_sys/srs_database/entry"
-require "rgeo/coord_sys/srs_database/url_reader"
-require "rgeo/coord_sys/srs_database/sr_org"
+require_relative "coord_sys/cs/factories"
+require_relative "coord_sys/cs/entities"
+require_relative "coord_sys/cs/wkt_parser"
+require_relative "coord_sys/srs_database/entry"
+require_relative "coord_sys/srs_database/url_reader"
+require_relative "coord_sys/srs_database/sr_org"
 
 module RGeo
   # This module provides data structures and tools related to coordinate

data/lib/rgeo/error.rb

@@ -14,6 +14,10 @@ module RGeo
     class RGeoError < RuntimeError
     end
 
+    # RGeo error specific to the GEOS implementation.
+    class GeosError < RGeoError
+    end
+
     # The specified geometry is invalid
     class InvalidGeometry < RGeoError
     end