rgeo 2.3.1 → 2.4.0

data/ext/geos_c_impl/line_string.c

@@ -11,6 +11,8 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "globals.h"
+
 #include "factory.h"
 #include "geometry.h"
 #include "point.h"
@@ -29,7 +31,7 @@ static VALUE method_line_string_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_line_string;
+    result = rgeo_feature_line_string_module;
   }
   return result;
 }
@@ -43,7 +45,7 @@ static VALUE method_linear_ring_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_linear_ring;
+    result = rgeo_feature_linear_ring_module;
   }
   return result;
 }
@@ -57,7 +59,7 @@ static VALUE method_line_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_line;
+    result = rgeo_feature_line_module;
   }
   return result;
 }
@@ -264,7 +266,7 @@ static VALUE method_line_string_project_point(VALUE self, VALUE point)
   factory_data = RGEO_FACTORY_DATA_PTR(factory);
 
   if(self_geom && point) {
-    geos_point = rgeo_convert_to_geos_geometry(factory, point, factory_data->globals->geos_point);
+    geos_point = rgeo_convert_to_geos_geometry(factory, point, rgeo_geos_point_class);
     location = GEOSProject_r(self_data->geos_context, self_geom, geos_point);
     result = DBL2NUM(location);
   }
@@ -290,7 +292,7 @@ static VALUE method_line_string_interpolate_point(VALUE self, VALUE loc_num)
 
   if(self_geom) {
     geos_point = GEOSInterpolate_r(self_data->geos_context, self_geom, location);
-    result = rgeo_wrap_geos_geometry(factory, geos_point, factory_data->globals->geos_point);
+    result = rgeo_wrap_geos_geometry(factory, geos_point, rgeo_geos_point_class);
   }
 
   return result;
@@ -358,8 +360,7 @@ static VALUE method_line_string_hash(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   factory = self_data->factory;
   hash = rb_hash_start(0);
-  hash = rgeo_geos_objbase_hash(factory,
-    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_line_string, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_line_string_module, hash);
   hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -374,8 +375,7 @@ static VALUE method_linear_ring_hash(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   factory = self_data->factory;
   hash = rb_hash_start(0);
-  hash = rgeo_geos_objbase_hash(factory,
-    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_linear_ring, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_linear_ring_module, hash);
   hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -390,8 +390,7 @@ static VALUE method_line_hash(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   factory = self_data->factory;
   hash = rb_hash_start(0);
-  hash = rgeo_geos_objbase_hash(factory,
-    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_line, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_line_module, hash);
   hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -415,7 +414,7 @@ static GEOSCoordSequence* coord_seq_from_array(VALUE factory, VALUE array, char
 
   Check_Type(array, T_ARRAY);
   factory_data = RGEO_FACTORY_DATA_PTR(factory);
-  point_type = factory_data->globals->feature_point;
+  point_type = rgeo_feature_point_module;
   len = (unsigned int)RARRAY_LEN(array);
   has_z = (char)(RGEO_FACTORY_DATA_PTR(factory)->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
   dims = has_z ? 3 : 2;
@@ -491,7 +490,7 @@ static VALUE cmethod_create_line_string(VALUE module, VALUE factory, VALUE array
     factory_data = RGEO_FACTORY_DATA_PTR(factory);
     geom = GEOSGeom_createLineString_r(factory_data->geos_context, coord_seq);
     if (geom) {
-      result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_line_string);
+      result = rgeo_wrap_geos_geometry(factory, geom, rgeo_geos_line_string_class);
     }
   }
   return result;
@@ -511,7 +510,7 @@ static VALUE cmethod_create_linear_ring(VALUE module, VALUE factory, VALUE array
     factory_data = RGEO_FACTORY_DATA_PTR(factory);
     geom = GEOSGeom_createLinearRing_r(factory_data->geos_context, coord_seq);
     if (geom) {
-      result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_linear_ring);
+      result = rgeo_wrap_geos_geometry(factory, geom, rgeo_geos_linear_ring_class);
     }
   }
   return result;
@@ -557,7 +556,7 @@ static VALUE cmethod_create_line(VALUE module, VALUE factory, VALUE start, VALUE
   result = Qnil;
   factory_data = RGEO_FACTORY_DATA_PTR(factory);
   has_z = (char)(factory_data->flags & RGEO_FACTORYFLAGS_SUPPORTS_Z_OR_M);
-  point_type = factory_data->globals->feature_point;
+  point_type = rgeo_feature_point_module;
   context = factory_data->geos_context;
 
   start_geom = rgeo_convert_to_geos_geometry(factory, start, point_type);
@@ -570,7 +569,7 @@ static VALUE cmethod_create_line(VALUE module, VALUE factory, VALUE start, VALUE
         populate_geom_into_coord_seq(context, end_geom, coord_seq, 1, has_z);
         geom = GEOSGeom_createLineString_r(context, coord_seq);
         if (geom) {
-          result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_line);
+          result = rgeo_wrap_geos_geometry(factory, geom, rgeo_geos_line_class);
         }
       }
     }
@@ -631,26 +630,26 @@ static VALUE cmethod_linear_ring_copy_from(VALUE klass, VALUE factory, VALUE ori
 }
 
 
-void rgeo_init_geos_line_string(RGeo_Globals* globals)
+void rgeo_init_geos_line_string()
 {
   VALUE geos_line_string_methods;
   VALUE geos_linear_ring_methods;
   VALUE geos_line_methods;
 
   // Class methods for CAPILineStringImpl
-  rb_define_module_function(globals->geos_line_string, "create", cmethod_create_line_string, 2);
-  rb_define_module_function(globals->geos_line_string, "_copy_from", cmethod_line_string_copy_from, 2);
+  rb_define_module_function(rgeo_geos_line_string_class, "create", cmethod_create_line_string, 2);
+  rb_define_module_function(rgeo_geos_line_string_class, "_copy_from", cmethod_line_string_copy_from, 2);
 
   // Class methods for CAPILinearRingImpl
-  rb_define_module_function(globals->geos_linear_ring, "create", cmethod_create_linear_ring, 2);
-  rb_define_module_function(globals->geos_linear_ring, "_copy_from", cmethod_linear_ring_copy_from, 2);
+  rb_define_module_function(rgeo_geos_linear_ring_class, "create", cmethod_create_linear_ring, 2);
+  rb_define_module_function(rgeo_geos_linear_ring_class, "_copy_from", cmethod_linear_ring_copy_from, 2);
 
   // Class methods for CAPILineImpl
-  rb_define_module_function(globals->geos_line, "create", cmethod_create_line, 3);
-  rb_define_module_function(globals->geos_line, "_copy_from", cmethod_line_copy_from, 2);
+  rb_define_module_function(rgeo_geos_line_class, "create", cmethod_create_line, 3);
+  rb_define_module_function(rgeo_geos_line_class, "_copy_from", cmethod_line_copy_from, 2);
 
   // CAPILineStringMethods module
-  geos_line_string_methods = rb_define_module_under(globals->geos_module, "CAPILineStringMethods");
+  geos_line_string_methods = rb_define_module_under(rgeo_geos_module, "CAPILineStringMethods");
   rb_define_method(geos_line_string_methods, "rep_equals?", method_line_string_eql, 1);
   rb_define_method(geos_line_string_methods, "eql?", method_line_string_eql, 1);
   rb_define_method(geos_line_string_methods, "hash", method_line_string_hash, 0);
@@ -668,12 +667,12 @@ void rgeo_init_geos_line_string(RGeo_Globals* globals)
   rb_define_method(geos_line_string_methods, "coordinates", method_line_string_coordinates, 0);
 
   // CAPILinearRingMethods module
-  geos_linear_ring_methods = rb_define_module_under(globals->geos_module, "CAPILinearRingMethods");
+  geos_linear_ring_methods = rb_define_module_under(rgeo_geos_module, "CAPILinearRingMethods");
   rb_define_method(geos_linear_ring_methods, "geometry_type", method_linear_ring_geometry_type, 0);
   rb_define_method(geos_linear_ring_methods, "hash", method_linear_ring_hash, 0);
 
   // CAPILineMethods module
-  geos_line_methods = rb_define_module_under(globals->geos_module, "CAPILineMethods");
+  geos_line_methods = rb_define_module_under(rgeo_geos_module, "CAPILineMethods");
   rb_define_method(geos_line_methods, "geometry_type", method_line_geometry_type, 0);
   rb_define_method(geos_line_methods, "hash", method_line_hash, 0);
 }

data/ext/geos_c_impl/line_string.h

@@ -9,8 +9,6 @@
 #include <ruby.h>
 #include <geos_c.h>
 
-#include "factory.h"
-
 RGEO_BEGIN_C
 
 
@@ -18,7 +16,7 @@ RGEO_BEGIN_C
   Initializes the line string module. This should be called after
   the geometry module is initialized.
 */
-void rgeo_init_geos_line_string(RGeo_Globals* globals);
+void rgeo_init_geos_line_string();
 
 /*
   Determines whether the given GEOS line string is closed.

data/ext/geos_c_impl/main.c

@@ -9,6 +9,8 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "globals.h"
+
 #include "errors.h"
 
 #include "factory.h"
@@ -26,15 +28,14 @@ RGEO_BEGIN_C
 void Init_geos_c_impl()
 {
 #ifdef RGEO_GEOS_SUPPORTED
-  RGeo_Globals* globals;
-
-  globals = rgeo_init_geos_factory();
-  rgeo_init_geos_geometry(globals);
-  rgeo_init_geos_point(globals);
-  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_globals();
+  rgeo_init_geos_factory();
+  rgeo_init_geos_geometry();
+  rgeo_init_geos_point();
+  rgeo_init_geos_line_string();
+  rgeo_init_geos_polygon();
+  rgeo_init_geos_geometry_collection();
+  rgeo_init_geos_analysis();
   rgeo_init_geos_errors();
 #endif
 }

data/ext/geos_c_impl/point.c

@@ -9,6 +9,8 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "globals.h"
+
 #include "factory.h"
 #include "geometry.h"
 #include "point.h"
@@ -26,7 +28,7 @@ static VALUE method_point_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_point;
+    result = rgeo_feature_point_module;
   }
   return result;
 }
@@ -168,8 +170,7 @@ static VALUE method_point_hash(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   factory = self_data->factory;
   hash = rb_hash_start(0);
-  hash = rgeo_geos_objbase_hash(factory,
-    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_point, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_point_module, hash);
   hash = rgeo_geos_coordseq_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -182,15 +183,15 @@ static VALUE cmethod_create(VALUE module, VALUE factory, VALUE x, VALUE y, VALUE
 }
 
 
-void rgeo_init_geos_point(RGeo_Globals* globals)
+void rgeo_init_geos_point()
 {
   VALUE geos_point_methods;
 
   // Class methods for CAPIPointImpl
-  rb_define_module_function(globals->geos_point, "create", cmethod_create, 4);
+  rb_define_module_function(rgeo_geos_point_class, "create", cmethod_create, 4);
 
   // CAPIPointMethods module
-  geos_point_methods = rb_define_module_under(globals->geos_module, "CAPIPointMethods");
+  geos_point_methods = rb_define_module_under(rgeo_geos_module, "CAPIPointMethods");
   rb_define_method(geos_point_methods, "rep_equals?", method_point_eql, 1);
   rb_define_method(geos_point_methods, "eql?", method_point_eql, 1);
   rb_define_method(geos_point_methods, "hash", method_point_hash, 0);
@@ -221,7 +222,7 @@ VALUE rgeo_create_geos_point(VALUE factory, double x, double y, double z)
         if (GEOSCoordSeq_setZ_r(context, coord_seq, 0, z)) {
           geom = GEOSGeom_createPoint_r(context, coord_seq);
           if (geom) {
-            result = rgeo_wrap_geos_geometry(factory, geom, factory_data->globals->geos_point);
+            result = rgeo_wrap_geos_geometry(factory, geom, rgeo_geos_point_class);
           }
         }
       }

data/ext/geos_c_impl/point.h

@@ -8,8 +8,6 @@
 
 #include <ruby.h>
 
-#include "factory.h"
-
 RGEO_BEGIN_C
 
 
@@ -17,7 +15,7 @@ RGEO_BEGIN_C
   Initializes the point module. This should be called after
   the geometry module is initialized.
 */
-void rgeo_init_geos_point(RGeo_Globals* globals);
+void rgeo_init_geos_point();
 
 /*
   Creates a 3d point and returns the ruby object.

data/ext/geos_c_impl/polygon.c

@@ -10,6 +10,8 @@
 #include <ruby.h>
 #include <geos_c.h>
 
+#include "globals.h"
+
 #include "factory.h"
 #include "geometry.h"
 #include "line_string.h"
@@ -43,8 +45,7 @@ static VALUE method_polygon_hash(VALUE self)
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   factory = self_data->factory;
   hash = rb_hash_start(0);
-  hash = rgeo_geos_objbase_hash(factory,
-    RGEO_FACTORY_DATA_PTR(factory)->globals->feature_polygon, hash);
+  hash = rgeo_geos_objbase_hash(factory, rgeo_feature_polygon_module, hash);
   hash = rgeo_geos_polygon_hash(self_data->geos_context, self_data->geom, hash);
   return LONG2FIX(rb_hash_end(hash));
 }
@@ -58,7 +59,7 @@ static VALUE method_polygon_geometry_type(VALUE self)
   result = Qnil;
   self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_polygon;
+    result = rgeo_feature_polygon_module;
   }
   return result;
 }
@@ -93,7 +94,7 @@ 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_FACTORY_DATA_PTR(self_data->factory)->globals->geos_point);
+    result = rgeo_wrap_geos_geometry(self_data->factory, GEOSGetCentroid_r(self_data->geos_context, self_geom), rgeo_geos_point_class);
   }
   return result;
 }
@@ -109,7 +110,7 @@ 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_FACTORY_DATA_PTR(self_data->factory)->globals->geos_point);
+    result = rgeo_wrap_geos_geometry(self_data->factory, GEOSPointOnSurface_r(self_data->geos_context, self_geom), rgeo_geos_point_class);
   }
   return result;
 }
@@ -145,7 +146,7 @@ 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_FACTORY_DATA_PTR(self_data->factory)->globals->geos_linear_ring);
+    result = rgeo_wrap_geos_geometry_clone(self_data->factory, GEOSGetExteriorRing_r(self_data->geos_context, self_geom), rgeo_geos_linear_ring_class);
   }
   return result;
 }
@@ -191,7 +192,7 @@ static VALUE method_polygon_interior_ring_n(VALUE self, VALUE n)
       if (i < num) {
         result = rgeo_wrap_geos_geometry_clone(self_data->factory,
           GEOSGetInteriorRingN_r(self_context, self_geom, i),
-          RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->geos_linear_ring);
+          rgeo_geos_linear_ring_class);
       }
     }
   }
@@ -219,9 +220,8 @@ static VALUE method_polygon_interior_rings(VALUE self)
     if (count >= 0) {
       result = rb_ary_new2(count);
       factory = self_data->factory;
-      linear_ring_class = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->geos_linear_ring;
       for (i=0; i<count; ++i) {
-        rb_ary_store(result, i, rgeo_wrap_geos_geometry_clone(factory, GEOSGetInteriorRingN_r(self_context, self_geom, i), linear_ring_class));
+        rb_ary_store(result, i, rgeo_wrap_geos_geometry_clone(factory, GEOSGetInteriorRingN_r(self_context, self_geom, i), rgeo_geos_linear_ring_class));
       }
     }
   }
@@ -244,7 +244,7 @@ static VALUE cmethod_create(VALUE module, VALUE factory, VALUE exterior, VALUE i
 
   Check_Type(interior_array, T_ARRAY);
   factory_data = RGEO_FACTORY_DATA_PTR(factory);
-  linear_ring_type = factory_data->globals->feature_linear_ring;
+  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;
@@ -262,7 +262,7 @@ static VALUE cmethod_create(VALUE module, VALUE factory, VALUE exterior, VALUE i
         polygon = GEOSGeom_createPolygon_r(context, exterior_geom, interior_geoms, actual_len);
         if (polygon) {
           free(interior_geoms);
-          return rgeo_wrap_geos_geometry(factory, polygon, factory_data->globals->geos_polygon);
+          return rgeo_wrap_geos_geometry(factory, polygon, rgeo_geos_polygon_class);
         }
       }
       for (i=0; i<actual_len; ++i) {
@@ -276,15 +276,15 @@ static VALUE cmethod_create(VALUE module, VALUE factory, VALUE exterior, VALUE i
 }
 
 
-void rgeo_init_geos_polygon(RGeo_Globals* globals)
+void rgeo_init_geos_polygon()
 {
   VALUE geos_polygon_methods;
 
   // Class methods for CAPIPolygonImpl
-  rb_define_module_function(globals->geos_polygon, "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(globals->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);

data/ext/geos_c_impl/polygon.h

@@ -9,8 +9,6 @@
 #include <ruby.h>
 #include <geos_c.h>
 
-#include "factory.h"
-
 RGEO_BEGIN_C
 
 
@@ -18,7 +16,7 @@ RGEO_BEGIN_C
   Initializes the polygon module. This should be called after
   the geometry module is initialized.
 */
-void rgeo_init_geos_polygon(RGeo_Globals* globals);
+void rgeo_init_geos_polygon();
 
 /*
   Comopares the values of two GEOS polygons. The two given geometries MUST

data/ext/geos_c_impl/preface.h

@@ -27,6 +27,11 @@
 #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

data/lib/rgeo/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RGeo
-  VERSION = "2.3.1"
+  VERSION = "2.4.0"
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: rgeo
 version: !ruby/object:Gem::Version
-  version: 2.3.1
+  version: 2.4.0
 platform: ruby
 authors:
 - Daniel Azuma
 - Tee Parham
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-30 00:00:00.000000000 Z
+date: 2022-01-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi-geos
@@ -110,6 +110,8 @@ files:
 - ext/geos_c_impl/geometry.h
 - ext/geos_c_impl/geometry_collection.c
 - ext/geos_c_impl/geometry_collection.h
+- ext/geos_c_impl/globals.c
+- ext/geos_c_impl/globals.h
 - ext/geos_c_impl/line_string.c
 - ext/geos_c_impl/line_string.h
 - ext/geos_c_impl/main.c
@@ -193,7 +195,7 @@ homepage: https://github.com/rgeo/rgeo
 licenses:
 - BSD-3-Clause
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -208,8 +210,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key: 
+rubygems_version: 3.1.6
+signing_key:
 specification_version: 4
 summary: RGeo is a geospatial data library for Ruby.
 test_files: []