rgeo 2.4.0 → 3.0.0

data/ext/geos_c_impl/polygon.c

@@ -2,27 +2,24 @@
   Polygon methods for GEOS wrapper
 */
 
-
 #include "preface.h"
 
 #ifdef RGEO_GEOS_SUPPORTED
 
-#include <ruby.h>
 #include <geos_c.h>
+#include <ruby.h>
 
-#include "globals.h"
-
+#include "coordinates.h"
 #include "factory.h"
 #include "geometry.h"
+#include "globals.h"
 #include "line_string.h"
 #include "polygon.h"
 
-#include "coordinates.h"
-
 RGEO_BEGIN_C
 
-
-static VALUE method_polygon_eql(VALUE self, VALUE rhs)
+static VALUE
+method_polygon_eql(VALUE self, VALUE rhs)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
@@ -30,13 +27,14 @@ 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->geom,
+                                             RGEO_GEOMETRY_DATA_PTR(rhs)->geom);
   }
   return result;
 }
 
-
-static VALUE method_polygon_hash(VALUE self)
+static VALUE
+method_polygon_hash(VALUE self)
 {
   st_index_t hash;
   RGeo_GeometryData* self_data;
@@ -46,12 +44,12 @@ static VALUE method_polygon_hash(VALUE self)
   factory = self_data->factory;
   hash = rb_hash_start(0);
   hash = rgeo_geos_objbase_hash(factory, rgeo_feature_polygon_module, hash);
-  hash = rgeo_geos_polygon_hash(self_data->geos_context, self_data->geom, hash);
+  hash = rgeo_geos_polygon_hash(self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
 
-
-static VALUE method_polygon_geometry_type(VALUE self)
+static VALUE
+method_polygon_geometry_type(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
@@ -64,8 +62,8 @@ static VALUE method_polygon_geometry_type(VALUE self)
   return result;
 }
 
-
-static VALUE method_polygon_area(VALUE self)
+static VALUE
+method_polygon_area(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
@@ -76,15 +74,15 @@ static VALUE method_polygon_area(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    if (GEOSArea_r(self_data->geos_context, self_geom, &area)) {
+    if (GEOSArea(self_geom, &area)) {
       result = rb_float_new(area);
     }
   }
   return result;
 }
 
-
-static VALUE method_polygon_centroid(VALUE self)
+static VALUE
+method_polygon_centroid(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
@@ -94,13 +92,14 @@ 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_geos_point_class);
+    result = rgeo_wrap_geos_geometry(
+      self_data->factory, GEOSGetCentroid(self_geom), rgeo_geos_point_class);
   }
   return result;
 }
 
-
-static VALUE method_polygon_point_on_surface(VALUE self)
+static VALUE
+method_polygon_point_on_surface(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
@@ -110,18 +109,18 @@ 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_geos_point_class);
+    result = rgeo_wrap_geos_geometry(
+      self_data->factory, GEOSPointOnSurface(self_geom), rgeo_geos_point_class);
   }
   return result;
 }
 
-
-static VALUE method_polygon_coordinates(VALUE self)
+static VALUE
+method_polygon_coordinates(VALUE self)
 {
   VALUE result = Qnil;
   RGeo_GeometryData* self_data;
   const GEOSGeometry* self_geom;
-  GEOSContextHandle_t self_context;
 
   int zCoordinate;
 
@@ -129,14 +128,15 @@ static VALUE method_polygon_coordinates(VALUE self)
   self_geom = self_data->geom;
 
   if (self_geom) {
-    zCoordinate = RGEO_FACTORY_DATA_PTR(self_data->factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M;
-    self_context = self_data->geos_context;
-    result = extract_points_from_polygon(self_context, self_geom, zCoordinate);
+    zCoordinate = RGEO_FACTORY_DATA_PTR(self_data->factory)->flags &
+                  RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M;
+    result = extract_points_from_polygon(self_geom, zCoordinate);
   }
   return result;
 }
 
-static VALUE method_polygon_exterior_ring(VALUE self)
+static VALUE
+method_polygon_exterior_ring(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
@@ -146,13 +146,15 @@ 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_geos_linear_ring_class);
+    result = rgeo_wrap_geos_geometry_clone(self_data->factory,
+                                           GEOSGetExteriorRing(self_geom),
+                                           rgeo_geos_linear_ring_class);
   }
   return result;
 }
 
-
-static VALUE method_polygon_num_interior_rings(VALUE self)
+static VALUE
+method_polygon_num_interior_rings(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
@@ -163,7 +165,7 @@ static VALUE method_polygon_num_interior_rings(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    num = GEOSGetNumInteriorRings_r(self_data->geos_context, self_geom);
+    num = GEOSGetNumInteriorRings(self_geom);
     if (num >= 0) {
       result = INT2NUM(num);
     }
@@ -171,186 +173,186 @@ static VALUE method_polygon_num_interior_rings(VALUE self)
   return result;
 }
 
-
-static VALUE method_polygon_interior_ring_n(VALUE self, VALUE n)
+static VALUE
+method_polygon_interior_ring_n(VALUE self, VALUE n)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
   const GEOSGeometry* self_geom;
   int i;
-  GEOSContextHandle_t self_context;
   int num;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    i = NUM2INT(n);
+    i = RB_NUM2INT(n);
     if (i >= 0) {
-      self_context = self_data->geos_context;
-      num = GEOSGetNumInteriorRings_r(self_context, self_geom);
+      num = GEOSGetNumInteriorRings(self_geom);
       if (i < num) {
-        result = rgeo_wrap_geos_geometry_clone(self_data->factory,
-          GEOSGetInteriorRingN_r(self_context, self_geom, i),
-          rgeo_geos_linear_ring_class);
+        result =
+          rgeo_wrap_geos_geometry_clone(self_data->factory,
+                                        GEOSGetInteriorRingN(self_geom, i),
+                                        rgeo_geos_linear_ring_class);
       }
     }
   }
   return result;
 }
 
-
-static VALUE method_polygon_interior_rings(VALUE self)
+static VALUE
+method_polygon_interior_rings(VALUE self)
 {
   VALUE result;
   RGeo_GeometryData* self_data;
   const GEOSGeometry* self_geom;
-  GEOSContextHandle_t self_context;
   int count;
   VALUE factory;
-  VALUE linear_ring_class;
   int i;
 
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   self_geom = self_data->geom;
   if (self_geom) {
-    self_context = self_data->geos_context;
-    count = GEOSGetNumInteriorRings_r(self_context, self_geom);
+    count = GEOSGetNumInteriorRings(self_geom);
     if (count >= 0) {
       result = rb_ary_new2(count);
       factory = self_data->factory;
-      for (i=0; i<count; ++i) {
-        rb_ary_store(result, i, rgeo_wrap_geos_geometry_clone(factory, GEOSGetInteriorRingN_r(self_context, self_geom, i), rgeo_geos_linear_ring_class));
+      for (i = 0; i < count; ++i) {
+        rb_ary_store(
+          result,
+          i,
+          rgeo_wrap_geos_geometry_clone(factory,
+                                        GEOSGetInteriorRingN(self_geom, i),
+                                        rgeo_geos_linear_ring_class));
       }
     }
   }
   return result;
 }
 
-
-static VALUE cmethod_create(VALUE module, VALUE factory, VALUE exterior, VALUE interior_array)
+static VALUE
+cmethod_create(VALUE module,
+               VALUE factory,
+               VALUE exterior,
+               VALUE interior_array)
 {
-  RGeo_FactoryData* factory_data;
   VALUE linear_ring_type;
   GEOSGeometry* exterior_geom;
-  GEOSContextHandle_t context;
   unsigned int len;
   GEOSGeometry** interior_geoms;
   unsigned int actual_len;
   unsigned int i;
+  unsigned int j;
   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;
-        }
-      }
-      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);
+  exterior_geom = rgeo_convert_to_detached_geos_geometry(
+    exterior, factory, linear_ring_type, NULL, &state);
+  if (state) {
+    rb_jump_tag(state);
+  }
+
+  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 (state) {
+        for (j = 0; j < i; j++) {
+          GEOSGeom_destroy(interior_geoms[j]);
         }
+        GEOSGeom_destroy(exterior_geom);
+        FREE(interior_geoms);
+        rb_jump_tag(state);
       }
-      for (i=0; i<actual_len; ++i) {
-        GEOSGeom_destroy_r(context, interior_geoms[i]);
+      interior_geoms[actual_len++] = interior_geom;
+    }
+    if (len == actual_len) {
+      polygon =
+        GEOSGeom_createPolygon(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(interior_geoms[i]);
+    }
+    FREE(interior_geoms);
+  }
+  GEOSGeom_destroy(exterior_geom);
+  if (state) {
+    rb_jump_tag(state);
   }
   return Qnil;
 }
 
-
-void rgeo_init_geos_polygon()
+void
+rgeo_init_geos_polygon()
 {
   VALUE geos_polygon_methods;
 
   // Class methods for CAPIPolygonImpl
-  rb_define_module_function(rgeo_geos_polygon_class, "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(rgeo_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);
-  rb_define_method(geos_polygon_methods, "geometry_type", method_polygon_geometry_type, 0);
+  rb_define_method(
+    geos_polygon_methods, "geometry_type", method_polygon_geometry_type, 0);
   rb_define_method(geos_polygon_methods, "area", method_polygon_area, 0);
-  rb_define_method(geos_polygon_methods, "centroid", method_polygon_centroid, 0);
-  rb_define_method(geos_polygon_methods, "point_on_surface", method_polygon_point_on_surface, 0);
-  rb_define_method(geos_polygon_methods, "exterior_ring", method_polygon_exterior_ring, 0);
-  rb_define_method(geos_polygon_methods, "num_interior_rings", method_polygon_num_interior_rings, 0);
-  rb_define_method(geos_polygon_methods, "interior_ring_n", method_polygon_interior_ring_n, 1);
-  rb_define_method(geos_polygon_methods, "interior_rings", method_polygon_interior_rings, 0);
-  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;
+  rb_define_method(
+    geos_polygon_methods, "centroid", method_polygon_centroid, 0);
+  rb_define_method(geos_polygon_methods,
+                   "point_on_surface",
+                   method_polygon_point_on_surface,
+                   0);
+  rb_define_method(
+    geos_polygon_methods, "exterior_ring", method_polygon_exterior_ring, 0);
+  rb_define_method(geos_polygon_methods,
+                   "num_interior_rings",
+                   method_polygon_num_interior_rings,
+                   0);
+  rb_define_method(
+    geos_polygon_methods, "interior_ring_n", method_polygon_interior_ring_n, 1);
+  rb_define_method(
+    geos_polygon_methods, "interior_rings", method_polygon_interior_rings, 0);
+  rb_define_method(
+    geos_polygon_methods, "coordinates", method_polygon_coordinates, 0);
 }
 
-
-st_index_t rgeo_geos_polygon_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash)
+st_index_t
+rgeo_geos_polygon_hash(const GEOSGeometry* geom, st_index_t hash)
 {
   unsigned int len;
   unsigned int i;
 
   if (geom) {
-    hash = rgeo_geos_coordseq_hash(context, GEOSGetExteriorRing_r(context, geom), hash);
-    len = GEOSGetNumInteriorRings_r(context, geom);
-    for (i=0; i<len; ++i) {
-      hash = rgeo_geos_coordseq_hash(context, GEOSGetInteriorRingN_r(context, geom, i), hash);
+    hash = rgeo_geos_coordseq_hash(GEOSGetExteriorRing(geom), hash);
+    len = GEOSGetNumInteriorRings(geom);
+    for (i = 0; i < len; ++i) {
+      hash = rgeo_geos_coordseq_hash(GEOSGetInteriorRingN(geom, i), hash);
     }
   }
   return hash;
 }
 
-
 RGEO_END_C
 
 #endif

data/ext/geos_c_impl/polygon.h

@@ -2,39 +2,41 @@
   Polygon methods for GEOS wrapper
 */
 
-
 #ifndef RGEO_GEOS_POLYGON_INCLUDED
 #define RGEO_GEOS_POLYGON_INCLUDED
 
-#include <ruby.h>
 #include <geos_c.h>
+#include <ruby.h>
 
 RGEO_BEGIN_C
 
-
 /*
   Initializes the polygon module. This should be called after
   the geometry module is initialized.
 */
-void rgeo_init_geos_polygon();
+void
+rgeo_init_geos_polygon();
 
 /*
-  Comopares the values of two GEOS polygons. The two given geometries MUST
+  Compares the values of two GEOS polygons. The two given geometries MUST
   be polygon types.
   Returns Qtrue if the polygons are equal, Qfalse if they are inequal, or
   Qnil if an error occurs.
 */
-VALUE rgeo_geos_polygons_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z);
+VALUE
+rgeo_geos_polygons_eql(const GEOSGeometry* geom1,
+                       const GEOSGeometry* geom2,
+                       char check_z);
 
 /*
   A tool for building up hash values.
-  You must pass in the context, a geos geometry, and a seed hash.
+  You must pass in a geos geometry, and a seed hash.
   Returns an updated hash.
   This call is useful in sequence, and should be bracketed by calls to
   rb_hash_start and rb_hash_end.
 */
-st_index_t rgeo_geos_polygon_hash(GEOSContextHandle_t context, const GEOSGeometry* geom, st_index_t hash);
-
+st_index_t
+rgeo_geos_polygon_hash(const GEOSGeometry* geom, st_index_t hash);
 
 RGEO_END_C
 

data/ext/geos_c_impl/preface.h

@@ -2,7 +2,6 @@
   Preface header for GEOS wrapper
 */
 
-
 #ifdef HAVE_GEOS_C_H
 #ifdef HAVE_GEOSSETSRID_R
 #define RGEO_GEOS_SUPPORTED
@@ -24,26 +23,25 @@
 #ifdef HAVE_GEOSCOORDSEQ_ISCCW_R
 #define RGEO_GEOS_SUPPORTS_ISCCW
 #endif
-#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
-#define rb_memhash(x,y) rgeo_internal_memhash(x,y)
-#define rb_hash_start(x) ((st_index_t)(x ^ 0xdeadbeef))
-#define rb_hash_end(x) ((st_index_t)(x ^ 0xbeefdead))
-#endif
-
 #ifdef __cplusplus
-#define RGEO_BEGIN_C extern "C" {
+#define RGEO_BEGIN_C                                                           \
+  extern "C"                                                                   \
+  {
 #define RGEO_END_C }
 #else
 #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,67 @@
+/*
+        Utilities for the ruby CAPI
+*/
+
+#ifndef RGEO_GEOS_RUBY_MORE_INCLUDED
+#define RGEO_GEOS_RUBY_MORE_INCLUDED
+
+#include "ruby_more.h"
+
+#include <ruby.h>
+
+#include "preface.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);
+}
+
+VALUE
+rb_exc_raise_value(VALUE exc)
+{
+  rb_exc_raise(exc);
+  return Qnil;
+}
+
+RGEO_END_C
+
+#endif

data/ext/geos_c_impl/ruby_more.h

@@ -0,0 +1,25 @@
+/*
+        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, ...);
+
+/*
+  Raises an error based on the exception passed in, but also returns
+  a VALUE rather than void. This is so we can pass it into rb_protect
+  without getting type mismatch warnings.
+*/
+VALUE
+rb_exc_raise_value(VALUE exc);
+
+RGEO_END_C
+
+#endif

data/lib/rgeo/cartesian/analysis.rb

@@ -10,7 +10,6 @@ module RGeo
   module Cartesian
     # This provides includes some spatial analysis algorithms supporting
     # Cartesian data.
-
     module Analysis
       class << self
         # Check orientation of a ring, returns `true` if it is counter-clockwise
@@ -79,8 +78,11 @@ module RGeo
           sin = 0.0
           cos = 1.0
           angs.each_slice(2) do |(x, y)|
-            ready = y > 0.0 && (sin > 0.0 || sin == 0.0 && direction == -1) || y < 0.0 && (sin < 0.0 || sin == 0.0 && direction == 1)
-            if y != 0.0
+            ready = y > 0.0 &&
+              (sin > 0.0 || sin == 0 && direction == -1) ||
+              y < 0.0 &&
+              (sin < 0.0 || sin == 0 && direction == 1)
+            unless y == 0
               s = sin * x + cos * y
               c = cos * x - sin * y
               r = Math.sqrt(s * s + c * c)