rgeo 3.0.0.pre.rc.2 → 3.0.0.pre.rc.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 939fdbb8c9bbcb94342b99f952ad5524cb436683ea054bcab0aaa408f362ac2a
-  data.tar.gz: 4cd0c59ee3e08947c646c1b7e5c9a9755c44a0a87459437754867bbb5c2e304e
+  metadata.gz: 91ca209240d93482556f0aaf2b1dcb3beca7710af47a3cba6b12014a09a8b3be
+  data.tar.gz: b22b62247f1c4f3d07d4e7e4c1552999ae42d1d0d94808cc2fa7805e48914acd
 SHA512:
-  metadata.gz: e6f02199e30b35334156d3a1107213b6dab9028572e423d2f0f6072a7a2032586e26dfa5a594a8132b33d4071f0d55f6bd75dcd60d1e5a60df4bde0c51b7a78f
-  data.tar.gz: 20404c7de6aec61e04eae659253ddf16f518afce40c64274d261acc1a160f5420866c8188fed18425e1a55788e5041ff9b7a93c653f61cdde0a7ce15dccfa1a1
+  metadata.gz: 803a18e2ccb670da3db22c630bda86bb6ad80643c8a3e4e6bae448a1e3003632904bdf90b2d7642601857c01b92ffbf4a5e354fd292fb85033db7c0e19cd49b3
+  data.tar.gz: 142ada28031864f3a2960605b504aa3daf222db98d190fc208589b31841f328cefb5192391594a6237b48d1aab907eae2250e63c12824ef65d22f6ca01546057

data/README.md

@@ -37,7 +37,7 @@ Use the core **rgeo** gem to:
 
 RGeo works with the following Ruby implementations:
 
-*   MRI Ruby 2.3.0 or later.
+*   MRI Ruby 2.6.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.

data/ext/geos_c_impl/analysis.c

@@ -6,14 +6,13 @@
 
 #ifdef RGEO_GEOS_SUPPORTED
 
-#include <ruby.h>
 #include <geos_c.h>
-
-#include "globals.h"
+#include <ruby.h>
 
 #include "analysis.h"
-#include "factory.h"
 #include "errors.h"
+#include "factory.h"
+#include "globals.h"
 
 RGEO_BEGIN_C
 
@@ -25,9 +24,9 @@ RGEO_BEGIN_C
  * otherwise.
  */
 #ifdef RGEO_GEOS_SUPPORTS_ISCCW
-VALUE rgeo_geos_analysis_ccw_p(VALUE self, VALUE ring)
+VALUE
+rgeo_geos_analysis_ccw_p(VALUE self, VALUE ring)
 {
-
   const RGeo_GeometryData* ring_data;
   const GEOSCoordSequence* coord_seq;
   char is_ccw;
@@ -36,17 +35,18 @@ VALUE rgeo_geos_analysis_ccw_p(VALUE self, VALUE 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(rb_eGeosError, "Could not retrieve CoordSeq from given ring."); }
-  if (!GEOSCoordSeq_isCCW_r(ring_data->geos_context, coord_seq, &is_ccw)) {
+  coord_seq = GEOSGeom_getCoordSeq(ring_data->geom);
+  if (!coord_seq) {
+    rb_raise(rb_eGeosError, "Could not retrieve CoordSeq from given ring.");
+  }
+  if (!GEOSCoordSeq_isCCW(coord_seq, &is_ccw)) {
     rb_raise(rb_eGeosError, "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
@@ -54,25 +54,28 @@ VALUE rgeo_geos_analysis_ccw_p(VALUE self, VALUE ring)
  * 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)
+VALUE
+rgeo_geos_analysis_supports_ccw(VALUE self)
 {
-  #ifdef RGEO_GEOS_SUPPORTS_ISCCW
-    return Qtrue;
-  #else
-    return Qfalse;
-  #endif
+#ifdef RGEO_GEOS_SUPPORTS_ISCCW
+  return Qtrue;
+#else
+  return Qfalse;
+#endif
 }
 
-
-void rgeo_init_geos_analysis()
+void
+rgeo_init_geos_analysis()
 {
   VALUE geos_analysis_module;
 
   geos_analysis_module = rb_define_module_under(rgeo_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
+  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

data/ext/geos_c_impl/analysis.h

@@ -19,19 +19,22 @@ RGEO_BEGIN_C
  * otherwise.
  */
 #ifdef RGEO_GEOS_SUPPORTS_CCW
-VALUE rgeo_geos_analysis_ccw_p(VALUE self, VALUE ring);
+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 
- * 
+ *   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);
+VALUE
+rgeo_geos_analysis_supports_ccw(VALUE self);
 
-void rgeo_init_geos_analysis();
+void
+rgeo_init_geos_analysis();
 
 RGEO_END_C
 

data/ext/geos_c_impl/coordinates.c

@@ -1,8 +1,9 @@
-#include <ruby.h>
 #include <geos_c.h>
+#include <ruby.h>
 
-
-VALUE extract_points_from_coordinate_sequence(GEOSContextHandle_t context, const GEOSCoordSequence* coord_sequence, int zCoordinate)
+VALUE
+extract_points_from_coordinate_sequence(const GEOSCoordSequence* coord_sequence,
+                                        int zCoordinate)
 {
   VALUE result = Qnil;
   VALUE point;
@@ -10,20 +11,20 @@ VALUE extract_points_from_coordinate_sequence(GEOSContextHandle_t context, const
   unsigned int i;
   double val;
 
-  if(GEOSCoordSeq_getSize_r(context, coord_sequence, &count)) {
+  if (GEOSCoordSeq_getSize(coord_sequence, &count)) {
     result = rb_ary_new2(count);
-    for(i = 0; i < count; ++i) {
-      if(zCoordinate) {
+    for (i = 0; i < count; ++i) {
+      if (zCoordinate) {
         point = rb_ary_new2(3);
       } else {
         point = rb_ary_new2(2);
       }
-      GEOSCoordSeq_getX_r(context, coord_sequence, i, &val);
+      GEOSCoordSeq_getX(coord_sequence, i, &val);
       rb_ary_push(point, rb_float_new(val));
-      GEOSCoordSeq_getY_r(context, coord_sequence, i, &val);
+      GEOSCoordSeq_getY(coord_sequence, i, &val);
       rb_ary_push(point, rb_float_new(val));
-      if(zCoordinate) {
-        GEOSCoordSeq_getZ_r(context, coord_sequence, i, &val);
+      if (zCoordinate) {
+        GEOSCoordSeq_getZ(coord_sequence, i, &val);
         rb_ary_push(point, rb_float_new(val));
       }
       rb_ary_push(result, point);
@@ -33,7 +34,8 @@ VALUE extract_points_from_coordinate_sequence(GEOSContextHandle_t context, const
   return result;
 }
 
-VALUE extract_points_from_polygon(GEOSContextHandle_t context, const GEOSGeometry* polygon, int zCoordinate)
+VALUE
+extract_points_from_polygon(const GEOSGeometry* polygon, int zCoordinate)
 {
   VALUE result = Qnil;
 
@@ -43,20 +45,24 @@ VALUE extract_points_from_polygon(GEOSContextHandle_t context, const GEOSGeometr
   unsigned int i;
 
   if (polygon) {
-    ring = GEOSGetExteriorRing_r(context, polygon);
-    coord_sequence = GEOSGeom_getCoordSeq_r(context, ring);
+    ring = GEOSGetExteriorRing(polygon);
+    coord_sequence = GEOSGeom_getCoordSeq(ring);
 
-    if(coord_sequence) {
-      interior_ring_count = GEOSGetNumInteriorRings_r(context, polygon);
+    if (coord_sequence) {
+      interior_ring_count = GEOSGetNumInteriorRings(polygon);
       result = rb_ary_new2(interior_ring_count + 1); // exterior + inner rings
 
-      rb_ary_push(result, extract_points_from_coordinate_sequence(context, coord_sequence, zCoordinate));
+      rb_ary_push(
+        result,
+        extract_points_from_coordinate_sequence(coord_sequence, zCoordinate));
 
-      for(i = 0; i < interior_ring_count; ++i) {
-        ring = GEOSGetInteriorRingN_r(context, polygon, i);
-        coord_sequence = GEOSGeom_getCoordSeq_r(context, ring);
-        if(coord_sequence) {
-          rb_ary_push(result, extract_points_from_coordinate_sequence(context, coord_sequence, zCoordinate));
+      for (i = 0; i < interior_ring_count; ++i) {
+        ring = GEOSGetInteriorRingN(polygon, i);
+        coord_sequence = GEOSGeom_getCoordSeq(ring);
+        if (coord_sequence) {
+          rb_ary_push(result,
+                      extract_points_from_coordinate_sequence(coord_sequence,
+                                                              zCoordinate));
         }
       }
     }

data/ext/geos_c_impl/coordinates.h

@@ -1,2 +1,5 @@
-VALUE extract_points_from_coordinate_sequence(GEOSContextHandle_t context, const GEOSCoordSequence* coord_sequence, int zCoordinate);
-VALUE extract_points_from_polygon(GEOSContextHandle_t context, const GEOSGeometry* polygon, int zCoordinate);
+VALUE
+extract_points_from_coordinate_sequence(const GEOSCoordSequence* coord_sequence,
+                                        int zCoordinate);
+VALUE
+extract_points_from_polygon(const GEOSGeometry* polygon, int zCoordinate);

data/ext/geos_c_impl/errors.c

@@ -8,26 +8,33 @@
 
 #ifdef RGEO_GEOS_SUPPORTED
 
-#include "globals.h"
-
 #include "errors.h"
+#include "globals.h"
 
 RGEO_BEGIN_C
 
 VALUE rb_eRGeoError;
 VALUE rb_eRGeoInvalidGeometry;
+VALUE rb_eRGeoParseError;
 VALUE rb_eRGeoUnsupportedOperation;
 VALUE rb_eGeosError;
 
-
-void rgeo_init_geos_errors() {
+void
+rgeo_init_geos_errors()
+{
   VALUE error_module;
 
   error_module = rb_define_module_under(rgeo_module, "Error");
-  rb_eRGeoError = rb_define_class_under(error_module, "RGeoError", rb_eRuntimeError);
-  rb_eRGeoInvalidGeometry = rb_define_class_under(error_module, "InvalidGeometry", rb_eRGeoError);
-  rb_eRGeoUnsupportedOperation = rb_define_class_under(error_module, "UnsupportedOperation", rb_eRGeoError);
-  rb_eGeosError = rb_define_class_under(error_module, "GeosError", rb_eRGeoError);
+  rb_eRGeoError =
+    rb_define_class_under(error_module, "RGeoError", rb_eRuntimeError);
+  rb_eRGeoInvalidGeometry =
+    rb_define_class_under(error_module, "InvalidGeometry", rb_eRGeoError);
+  rb_eRGeoUnsupportedOperation =
+    rb_define_class_under(error_module, "UnsupportedOperation", rb_eRGeoError);
+  rb_eRGeoParseError =
+    rb_define_class_under(error_module, "ParseError", rb_eRGeoError);
+  rb_eGeosError =
+    rb_define_class_under(error_module, "GeosError", rb_eRGeoError);
 }
 
 RGEO_END_C

data/ext/geos_c_impl/errors.h

@@ -12,12 +12,15 @@ RGEO_BEGIN_C
 extern VALUE rb_eRGeoError;
 // RGeo::Error::InvalidGeometry
 extern VALUE rb_eRGeoInvalidGeometry;
+// RGeo::Error::ParseError
+extern VALUE rb_eRGeoParseError;
 // RGeo::Error::UnsupportedOperation
 extern VALUE rb_eRGeoUnsupportedOperation;
 // RGeo error specific to the GEOS implementation.
 extern VALUE rb_eGeosError;
 
-void rgeo_init_geos_errors();
+void
+rgeo_init_geos_errors();
 
 RGEO_END_C
 

data/ext/geos_c_impl/extconf.rb

@@ -6,45 +6,55 @@
 #
 # -----------------------------------------------------------------------------
 def create_dummy_makefile
-  File.open("Makefile", "w") { |f_| f_.write(".PHONY: install\ninstall:\n") }
+  File.write("Makefile", ".PHONY: install\ninstall:\n")
 end
 
 if RUBY_DESCRIPTION =~ /^jruby\s/
   create_dummy_makefile
-else
-  require "mkmf"
+  exit
+end
 
-  $CFLAGS << " -DRGEO_GEOS_DEBUG" if ENV.key?("DEBUG") || ENV.key?("RGEO_GEOS_DEBUG")
+require "mkmf"
 
-  geosconfig = with_config("geos-config") || find_executable("geos-config")
+if ENV.key?("DEBUG") || ENV.key?("MAINTAINER_MODE")
+  $CFLAGS << " -DDEBUG" \
+             " -Wall" \
+             " -ggdb" \
+             " -pedantic" \
+             " -std=c17"
 
-  if geosconfig
-    puts "Using GEOS compile configuration from #{geosconfig}"
-    $INCFLAGS << " " << `#{geosconfig} --cflags`.strip
-    geos_libs = `#{geosconfig} --clibs`.tr("\n", " ")
-    geos_libs.split(/\s+/).each do |flag|
-      $libs << " " + flag unless $libs.include?(flag)
-    end
-  end
+  extra_flags = ENV.fetch("MAINTAINER_MODE", ENV.fetch("DEBUG", ""))
+  $CFLAGS << " " << extra_flags if extra_flags.strip.start_with?("-")
+end
+
+geosconfig = with_config("geos-config") || find_executable("geos-config")
 
-  found_geos_ = false
-  if have_header("geos_c.h")
-    found_geos_ = true if have_func("GEOSSetSRID_r", "geos_c.h")
-    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")
-    have_func("rb_gc_mark_movable", "ruby.h")
+if geosconfig
+  puts "Using GEOS compile configuration from #{geosconfig}"
+  $INCFLAGS << " " << IO.popen([geosconfig, "--cflags"], &:read).strip
+  geos_libs = IO.popen([geosconfig, "--clibs"], &:read)
+  geos_libs.split.each do |flag|
+    $libs << " " << flag unless $libs.include?(flag)
   end
+end
 
-  if found_geos_
-    create_makefile("rgeo/geos/geos_c_impl")
-  else
-    puts "**** WARNING: Unable to find GEOS headers or libraries."
-    puts "**** Ensure that 'geos-config' is in your PATH or provide that full path via --with-geos-config"
-    puts "**** Compiling without GEOS support."
+found_geos = false
+if have_header("geos_c.h")
+  found_geos = true if have_func("GEOSSetSRID_r", "geos_c.h")
+  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")
+  have_func("rb_gc_mark_movable", "ruby.h")
+end
 
-    create_dummy_makefile
-  end
+if found_geos
+  create_makefile("rgeo/geos/geos_c_impl")
+else
+  puts "**** WARNING: Unable to find GEOS headers or libraries."
+  puts "**** Ensure that 'geos-config' is in your PATH or provide that full path via --with-geos-config"
+  puts "**** Compiling without GEOS support."
+
+  create_dummy_makefile
 end