rgeo 0.3.2 → 0.3.3

data/History.rdoc

@@ -1,3 +1,11 @@
+=== 0.3.3 / 2011-12-19
+
+* Recognizes MultiPoint WKTs in which individual points are not contained in parens. This is technically incorrect syntax, but apparently there are examples in the wild so we are now supporting it. (Reported by J Smith.)
+* The Geos CAPI implementation sometimes returned the wrong result from GeometryCollection#geometry_n. Fixed.
+* Fixed a hang when validating certain projected linestrings. (Patch contributed by Toby Rahilly.)
+* Several rdoc updates (including a contribution by Andy Allan).
+* Separated declarations and code in the C extensions to avert warnings on some compilers.
+
 === 0.3.2 / 2011-08-11
 
 * Some objects can now be serialized and deserialized via Marshal or YAML. Supported objects include OGC coordinate systems, Proj4 coordinate systems, and WKRep parsers/generators. Factories and geometries will be supported shortly.

data/Version

@@ -1 +1 @@
-0.3.2
+0.3.3

data/ext/geos_c_impl/extconf.rb

@@ -50,7 +50,7 @@ else
      '/opt/geos/include',
      '/opt/include',
      '/Library/Frameworks/GEOS.framework/unix/include',
-     ::Config::CONFIG['includedir'],
+     ::RbConfig::CONFIG['includedir'],
      '/usr/include',
     ]
   lib_dirs_ =
@@ -61,7 +61,7 @@ else
      '/opt/geos/lib',
      '/opt/lib',
      '/Library/Frameworks/GEOS.framework/unix/lib',
-     ::Config::CONFIG['libdir'],
+     ::RbConfig::CONFIG['libdir'],
      '/usr/lib',
     ]
   header_dirs_.delete_if{ |path_| !::File.directory?(path_) }

data/ext/geos_c_impl/factory.c

@@ -92,10 +92,12 @@ static void destroy_factory_func(RGeo_FactoryData* data)
 
 static void destroy_geometry_func(RGeo_GeometryData* data)
 {
+  const GEOSPreparedGeometry* prep;
+
   if (data->geom) {
     GEOSGeom_destroy_r(data->geos_context, data->geom);
   }
-  const GEOSPreparedGeometry* prep = data->prep;
+  prep = data->prep;
   if (prep && prep != (const GEOSPreparedGeometry*)1 && prep != (const GEOSPreparedGeometry*)2 &&
     prep != (const GEOSPreparedGeometry*)3)
   {
@@ -173,17 +175,23 @@ static VALUE method_factory_flags(VALUE self)
 
 static VALUE method_factory_parse_wkt(VALUE self, VALUE str)
 {
+  RGeo_FactoryData* self_data;
+  GEOSContextHandle_t self_context;
+  GEOSWKTReader* wkt_reader;
+  VALUE result;
+  GEOSGeometry* geom;
+  
   Check_Type(str, T_STRING);
-  RGeo_FactoryData* self_data = RGEO_FACTORY_DATA_PTR(self);
-  GEOSContextHandle_t self_context = self_data->geos_context;
-  GEOSWKTReader* wkt_reader = self_data->wkt_reader;
+  self_data = RGEO_FACTORY_DATA_PTR(self);
+  self_context = self_data->geos_context;
+  wkt_reader = self_data->wkt_reader;
   if (!wkt_reader) {
     wkt_reader = GEOSWKTReader_create_r(self_context);
     self_data->wkt_reader = wkt_reader;
   }
-  VALUE result = Qnil;
+  result = Qnil;
   if (wkt_reader) {
-    GEOSGeometry* geom = GEOSWKTReader_read_r(self_context, wkt_reader, RSTRING_PTR(str));
+    geom = GEOSWKTReader_read_r(self_context, wkt_reader, RSTRING_PTR(str));
     if (geom) {
       result = rgeo_wrap_geos_geometry(self, geom, Qnil);
     }
@@ -194,17 +202,23 @@ static VALUE method_factory_parse_wkt(VALUE self, VALUE str)
 
 static VALUE method_factory_parse_wkb(VALUE self, VALUE str)
 {
+  RGeo_FactoryData* self_data;
+  GEOSContextHandle_t self_context;
+  GEOSWKBReader* wkb_reader;
+  VALUE result;
+  GEOSGeometry* geom;
+  
   Check_Type(str, T_STRING);
-  RGeo_FactoryData* self_data = RGEO_FACTORY_DATA_PTR(self);
-  GEOSContextHandle_t self_context = self_data->geos_context;
-  GEOSWKBReader* wkb_reader = self_data->wkb_reader;
+  self_data = RGEO_FACTORY_DATA_PTR(self);
+  self_context = self_data->geos_context;
+  wkb_reader = self_data->wkb_reader;
   if (!wkb_reader) {
     wkb_reader = GEOSWKBReader_create_r(self_context);
     self_data->wkb_reader = wkb_reader;
   }
-  VALUE result = Qnil;
+  result = Qnil;
   if (wkb_reader) {
-    GEOSGeometry* geom = GEOSWKBReader_read_r(self_context, wkb_reader, (unsigned char*)RSTRING_PTR(str), (size_t)RSTRING_LEN(str));
+    geom = GEOSWKBReader_read_r(self_context, wkb_reader, (unsigned char*)RSTRING_PTR(str), (size_t)RSTRING_LEN(str));
     if (geom) {
       result = rgeo_wrap_geos_geometry(self, geom, Qnil);
     }
@@ -216,12 +230,17 @@ static VALUE method_factory_parse_wkb(VALUE self, VALUE str)
 static VALUE cmethod_factory_create(VALUE klass, VALUE flags, VALUE srid, VALUE buffer_resolution,
   VALUE wkt_generator, VALUE wkb_generator)
 {
-  VALUE result = Qnil;
-  RGeo_FactoryData* data = ALLOC(RGeo_FactoryData);
+  VALUE result;
+  RGeo_FactoryData* data;
+  GEOSContextHandle_t context;
+  VALUE wrapped_globals;
+  
+  result = Qnil;
+  data = ALLOC(RGeo_FactoryData);
   if (data) {
-    GEOSContextHandle_t context = initGEOS_r(message_handler, message_handler);
+    context = initGEOS_r(message_handler, message_handler);
     if (context) {
-      VALUE wrapped_globals = rb_const_get_at(klass, rb_intern("INTERNAL_CGLOBALS"));
+      wrapped_globals = rb_const_get_at(klass, rb_intern("INTERNAL_CGLOBALS"));
       data->globals = (RGeo_Globals*)DATA_PTR(wrapped_globals);
       data->geos_context = context;
       data->flags = NUM2INT(flags);
@@ -248,14 +267,19 @@ static VALUE cmethod_factory_create(VALUE klass, VALUE flags, VALUE srid, VALUE
 
 RGeo_Globals* rgeo_init_geos_factory()
 {
-  RGeo_Globals* globals = ALLOC(RGeo_Globals);
-  VALUE rgeo_module = rb_define_module("RGeo");
+  RGeo_Globals* globals;
+  VALUE rgeo_module;
+  VALUE geos_factory_class;
+  VALUE wrapped_globals;
+
+  globals = ALLOC(RGeo_Globals);
+  rgeo_module = rb_define_module("RGeo");
   globals->geos_module = rb_define_module_under(rgeo_module, "Geos");
   globals->feature_module = rb_define_module_under(rgeo_module, "Feature");
   globals->global_mixins = rb_const_get_at(rb_const_get_at(globals->feature_module, rb_intern("MixinCollection")), rb_intern("GLOBAL"));
   
   // Add C methods to the factory.
-  VALUE geos_factory_class = rb_const_get_at(globals->geos_module, rb_intern("Factory"));
+  geos_factory_class = rb_const_get_at(globals->geos_module, rb_intern("Factory"));
   rb_define_method(geos_factory_class, "_parse_wkt_impl", method_factory_parse_wkt, 1);
   rb_define_method(geos_factory_class, "_parse_wkb_impl", method_factory_parse_wkb, 1);
   rb_define_method(geos_factory_class, "_srid", method_factory_srid, 0);
@@ -265,7 +289,7 @@ RGeo_Globals* rgeo_init_geos_factory()
   
   // Wrap the globals in a Ruby object and store it off so we have access
   // to it later. Each factory instance will reference it internally.
-  VALUE wrapped_globals = Data_Wrap_Struct(rb_cObject, mark_globals_func, destroy_globals_func, globals);
+  wrapped_globals = Data_Wrap_Struct(rb_cObject, mark_globals_func, destroy_globals_func, globals);
   rb_define_const(geos_factory_class, "INTERNAL_CGLOBALS", wrapped_globals);
   
   return globals;
@@ -277,15 +301,24 @@ RGeo_Globals* rgeo_init_geos_factory()
 
 VALUE rgeo_wrap_geos_geometry(VALUE factory, GEOSGeometry* geom, VALUE klass)
 {
-  VALUE result = Qnil;
+  VALUE result;
+  RGeo_FactoryData* factory_data;
+  GEOSContextHandle_t factory_context;
+  VALUE klasses;
+  RGeo_Globals* globals;
+  VALUE inferred_klass;
+  char is_collection;
+  RGeo_GeometryData* data;
+
+  result = Qnil;
   if (geom || !NIL_P(klass)) {
-    RGeo_FactoryData* factory_data = NIL_P(factory) ? NULL : RGEO_FACTORY_DATA_PTR(factory);
-    GEOSContextHandle_t factory_context = factory_data ? factory_data->geos_context : NULL;
-    VALUE klasses = Qnil;
+    factory_data = NIL_P(factory) ? NULL : RGEO_FACTORY_DATA_PTR(factory);
+    factory_context = factory_data ? factory_data->geos_context : NULL;
+    klasses = Qnil;
     if (TYPE(klass) != T_CLASS) {
-      RGeo_Globals* globals = factory_data->globals;
-      VALUE inferred_klass = Qnil;
-      char is_collection = 0;
+      globals = factory_data->globals;
+      inferred_klass = Qnil;
+      is_collection = 0;
       switch (GEOSGeomTypeId_r(factory_context, geom)) {
       case GEOS_POINT:
         inferred_klass = globals->geos_point;
@@ -324,7 +357,7 @@ VALUE rgeo_wrap_geos_geometry(VALUE factory, GEOSGeometry* geom, VALUE klass)
       }
       klass = inferred_klass;
     }
-    RGeo_GeometryData* data = ALLOC(RGeo_GeometryData);
+    data = ALLOC(RGeo_GeometryData);
     if (data) {
       if (geom) {
         GEOSSetSRID_r(factory_context, geom, factory_data->srid);
@@ -344,9 +377,12 @@ VALUE rgeo_wrap_geos_geometry(VALUE factory, GEOSGeometry* geom, VALUE klass)
 
 VALUE rgeo_wrap_geos_geometry_clone(VALUE factory, const GEOSGeometry* geom, VALUE klass)
 {
-  VALUE result = Qnil;
+  VALUE result;
+  GEOSGeometry* clone_geom;
+
+  result = Qnil;
   if (geom) {
-    GEOSGeometry* clone_geom = GEOSGeom_clone_r(RGEO_FACTORY_DATA_PTR(factory)->geos_context, geom);
+    clone_geom = GEOSGeom_clone_r(RGEO_FACTORY_DATA_PTR(factory)->geos_context, geom);
     if (clone_geom) {
       result = rgeo_wrap_geos_geometry(factory, clone_geom, klass);
     }
@@ -358,13 +394,15 @@ 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;
+
   if (NIL_P(type) && RGEO_GEOMETRY_DATA_PTR(obj)->factory == factory) {
     object = obj;
   }
   else {
     object = rb_funcall(RGEO_FACTORY_DATA_PTR(factory)->globals->feature_module, rb_intern("cast"), 3, obj, factory, type);
   }
-  const GEOSGeometry* geom = NULL;
+  geom = NULL;
   if (!NIL_P(object)) {
     geom = RGEO_GEOMETRY_DATA_PTR(object)->geom;
   }
@@ -374,13 +412,18 @@ const GEOSGeometry* rgeo_convert_to_geos_geometry(VALUE factory, VALUE obj, VALU
 
 GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, VALUE type, VALUE* klasses)
 {
+  VALUE object;
+  GEOSGeometry* geom;
+  RGeo_GeometryData* object_data;
+  const GEOSPreparedGeometry* prep;
+
   if (klasses) {
     *klasses = Qnil;
   }
-  VALUE object = rb_funcall(RGEO_FACTORY_DATA_PTR(factory)->globals->feature_module, rb_intern("cast"), 5, obj, factory, type, ID2SYM(rb_intern("force_new")), ID2SYM(rb_intern("keep_subtype")));
-  GEOSGeometry* geom = NULL;
+  object = rb_funcall(RGEO_FACTORY_DATA_PTR(factory)->globals->feature_module, rb_intern("cast"), 5, obj, factory, type, ID2SYM(rb_intern("force_new")), ID2SYM(rb_intern("keep_subtype")));
+  geom = NULL;
   if (!NIL_P(object)) {
-    RGeo_GeometryData* object_data = RGEO_GEOMETRY_DATA_PTR(object);
+    object_data = RGEO_GEOMETRY_DATA_PTR(object);
     geom = object_data->geom;
     if (klasses) {
       *klasses = object_data->klasses;
@@ -388,7 +431,7 @@ GEOSGeometry* rgeo_convert_to_detached_geos_geometry(VALUE obj, VALUE factory, V
         *klasses = CLASS_OF(object);
       }
     }
-    const GEOSPreparedGeometry* prep = object_data->prep;
+    prep = object_data->prep;
     if (prep && prep != (GEOSPreparedGeometry*)1 && prep != (GEOSPreparedGeometry*)2) {
       GEOSPreparedGeom_destroy_r(object_data->geos_context, prep);
     }
@@ -416,18 +459,24 @@ const GEOSGeometry* rgeo_get_geos_geometry_safe(VALUE obj)
 
 VALUE rgeo_geos_coordseqs_eql(GEOSContextHandle_t context, const GEOSGeometry* geom1, const GEOSGeometry* geom2, char check_z)
 {
-  VALUE result = Qnil;
+  VALUE result;
+  const GEOSCoordSequence* cs1;
+  const GEOSCoordSequence* cs2;
+  unsigned int len1;
+  unsigned int len2;
+  unsigned int i;
+  double val1, val2;
+
+  result = Qnil;
   if (geom1 && geom2) {
-    const GEOSCoordSequence* cs1 = GEOSGeom_getCoordSeq_r(context, geom1);
-    const GEOSCoordSequence* cs2 = GEOSGeom_getCoordSeq_r(context, geom2);
+    cs1 = GEOSGeom_getCoordSeq_r(context, geom1);
+    cs2 = GEOSGeom_getCoordSeq_r(context, geom2);
     if (cs1 && cs2) {
-      unsigned int len1 = 0;
-      unsigned int len2 = 0;
+      len1 = 0;
+      len2 = 0;
       if (GEOSCoordSeq_getSize_r(context, cs1, &len1) && GEOSCoordSeq_getSize_r(context, cs2, &len2)) {
         if (len1 == len2) {
           result = Qtrue;
-          unsigned int i;
-          double val1, val2;
           for (i=0; i<len1; ++i) {
             if (GEOSCoordSeq_getX_r(context, cs1, i, &val1) && GEOSCoordSeq_getX_r(context, cs2, i, &val2)) {
               if (val1 == val2) {
@@ -483,7 +532,9 @@ VALUE rgeo_geos_coordseqs_eql(GEOSContextHandle_t context, const GEOSGeometry* g
 
 VALUE rgeo_geos_klasses_and_factories_eql(VALUE obj1, VALUE obj2)
 {
-  VALUE result = Qnil;
+  VALUE result;
+  
+  result = Qnil;
   if (rb_obj_class(obj1) != rb_obj_class(obj2)) {
     result = Qfalse;
   }

data/ext/geos_c_impl/geometry.c

@@ -57,8 +57,12 @@ RGEO_BEGIN_C
 
 static int compute_dimension(GEOSContextHandle_t context, const GEOSGeometry* geom)
 {
-  int result = -1;
-  int size, i;
+  int result;
+  int size;
+  int i;
+  int dim;
+
+  result = -1;
   if (geom) {
     switch (GEOSGeomTypeId_r(context, geom)) {
     case GEOS_POINT:
@@ -89,7 +93,7 @@ static int compute_dimension(GEOSContextHandle_t context, const GEOSGeometry* ge
     case GEOS_GEOMETRYCOLLECTION:
       size = GEOSGetNumGeometries_r(context, geom);
       for (i=0; i<size; ++i) {
-        int dim = compute_dimension(context, GEOSGetGeometryN_r(context, geom, i));
+        dim = compute_dimension(context, GEOSGetGeometryN_r(context, geom, i));
         if (dim > result) {
           result = dim;
         }
@@ -105,7 +109,9 @@ static int compute_dimension(GEOSContextHandle_t context, const GEOSGeometry* ge
 
 static const GEOSPreparedGeometry* rgeo_request_prepared_geometry(RGeo_GeometryData* object_data)
 {
-  const GEOSPreparedGeometry* prep = object_data->prep;
+  const GEOSPreparedGeometry* prep;
+
+  prep = object_data->prep;
   if (prep == (const GEOSPreparedGeometry*)1) {
     object_data->prep = (GEOSPreparedGeometry*)2;
     prep = NULL;
@@ -155,7 +161,9 @@ static VALUE method_geometry_set_factory(VALUE self, VALUE factory)
 
 static VALUE method_geometry_prepared_p(VALUE self)
 {
-  const GEOSPreparedGeometry* prep = RGEO_GEOMETRY_DATA_PTR(self)->prep;
+  const GEOSPreparedGeometry* prep;
+
+  prep = RGEO_GEOMETRY_DATA_PTR(self)->prep;
   return (prep && prep != (const GEOSPreparedGeometry*)1 &&
     prep != (const GEOSPreparedGeometry*)2 &&
     prep != (GEOSPreparedGeometry*)3) ? Qtrue : Qfalse;
@@ -164,11 +172,14 @@ static VALUE method_geometry_prepared_p(VALUE self)
 
 static VALUE method_geometry_prepare(VALUE self)
 {
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  RGeo_GeometryData* self_data;
+  const GEOSPreparedGeometry* prep;
+
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
-    const GEOSPreparedGeometry* prep = self_data->prep;
+    prep = self_data->prep;
     if (!prep || prep == (const GEOSPreparedGeometry*)1 || prep == (const GEOSPreparedGeometry*)2) {
-      const GEOSPreparedGeometry* prep = GEOSPrepare_r(self_data->geos_context, self_data->geom);
+      prep = GEOSPrepare_r(self_data->geos_context, self_data->geom);
       if (prep) {
         self_data->prep = prep;
       }
@@ -183,9 +194,13 @@ static VALUE method_geometry_prepare(VALUE self)
 
 static VALUE method_geometry_dimension(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
     result = INT2NUM(compute_dimension(self_data->geos_context, self_geom));
   }
@@ -195,9 +210,13 @@ static VALUE method_geometry_dimension(VALUE self)
 
 static VALUE method_geometry_geometry_type(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
     result = RGEO_FACTORY_DATA_PTR(self_data->factory)->globals->feature_geometry;
   }
@@ -207,9 +226,13 @@ static VALUE method_geometry_geometry_type(VALUE self)
 
 static VALUE method_geometry_srid(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
     result = INT2NUM(GEOSGetSRID_r(self_data->geos_context, self_geom));
   }
@@ -219,12 +242,18 @@ static VALUE method_geometry_srid(VALUE self)
 
 static VALUE method_geometry_envelope(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  GEOSContextHandle_t geos_context;
+  GEOSGeometry* envelope;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    GEOSContextHandle_t geos_context = self_data->geos_context;
-    GEOSGeometry* envelope = GEOSEnvelope_r(geos_context, self_geom);
+    geos_context = self_data->geos_context;
+    envelope = GEOSEnvelope_r(geos_context, 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 ||
@@ -243,12 +272,18 @@ static VALUE method_geometry_envelope(VALUE self)
 
 static VALUE method_geometry_boundary(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  GEOSContextHandle_t geos_context;
+  GEOSGeometry* boundary;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    GEOSContextHandle_t geos_context = self_data->geos_context;
-    GEOSGeometry* boundary = GEOSBoundary_r(geos_context, self_geom);
+    geos_context = self_data->geos_context;
+    boundary = GEOSBoundary_r(geos_context, self_geom);
     if (boundary) {
       result = rgeo_wrap_geos_geometry(self_data->factory, boundary, Qnil);
     }
@@ -259,23 +294,32 @@ static VALUE method_geometry_boundary(VALUE self)
 
 static VALUE method_geometry_as_text(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  RGeo_FactoryData* factory_data;
+  VALUE wkt_generator;
+  GEOSWKTWriter* wkt_writer;
+  GEOSContextHandle_t geos_context;
+  char* str;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    RGeo_FactoryData* factory_data = RGEO_FACTORY_DATA_PTR(self_data->factory);
-    VALUE wkt_generator = factory_data->wkrep_wkt_generator;
+    factory_data = RGEO_FACTORY_DATA_PTR(self_data->factory);
+    wkt_generator = factory_data->wkrep_wkt_generator;
     if (!NIL_P(wkt_generator)) {
       result = rb_funcall(wkt_generator, rb_intern("generate"), 1, self);
     }
     else {
-      GEOSWKTWriter* wkt_writer = factory_data->wkt_writer;
-      GEOSContextHandle_t geos_context = self_data->geos_context;
+      wkt_writer = factory_data->wkt_writer;
+      geos_context = self_data->geos_context;
       if (!wkt_writer) {
         wkt_writer = GEOSWKTWriter_create_r(geos_context);
         factory_data->wkt_writer = wkt_writer;
       }
-      char* str = GEOSWKTWriter_write_r(geos_context, wkt_writer, self_geom);
+      str = GEOSWKTWriter_write_r(geos_context, wkt_writer, self_geom);
       if (str) {
         result = rb_str_new2(str);
         GEOSFree_r(geos_context, str);
@@ -288,24 +332,33 @@ static VALUE method_geometry_as_text(VALUE self)
 
 static VALUE method_geometry_as_binary(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  RGeo_FactoryData* factory_data;
+  VALUE wkb_generator;
+  GEOSWKBWriter* wkb_writer;
+  GEOSContextHandle_t geos_context;
+  size_t size;
+  char* str;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    RGeo_FactoryData* factory_data = RGEO_FACTORY_DATA_PTR(self_data->factory);
-    VALUE wkb_generator = factory_data->wkrep_wkb_generator;
+    factory_data = RGEO_FACTORY_DATA_PTR(self_data->factory);
+    wkb_generator = factory_data->wkrep_wkb_generator;
     if (!NIL_P(wkb_generator)) {
       result = rb_funcall(wkb_generator, rb_intern("generate"), 1, self);
     }
     else {
-      GEOSWKBWriter* wkb_writer = factory_data->wkb_writer;
-      GEOSContextHandle_t geos_context = self_data->geos_context;
+      wkb_writer = factory_data->wkb_writer;
+      geos_context = self_data->geos_context;
       if (!wkb_writer) {
         wkb_writer = GEOSWKBWriter_create_r(geos_context);
         factory_data->wkb_writer = wkb_writer;
       }
-      size_t size;
-      char* str = (char*)GEOSWKBWriter_write_r(geos_context, wkb_writer, self_geom, &size);
+      str = (char*)GEOSWKBWriter_write_r(geos_context, wkb_writer, self_geom, &size);
       if (str) {
         result = rb_str_new(str, size);
         GEOSFree_r(geos_context, str);
@@ -318,11 +371,16 @@ static VALUE method_geometry_as_binary(VALUE self)
 
 static VALUE method_geometry_is_empty(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  char val;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    char val = GEOSisEmpty_r(self_data->geos_context, self_geom);
+    val = GEOSisEmpty_r(self_data->geos_context, self_geom);
     if (val == 0) {
       result = Qfalse;
     }
@@ -336,11 +394,16 @@ static VALUE method_geometry_is_empty(VALUE self)
 
 static VALUE method_geometry_is_simple(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  char val;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    char val = GEOSisSimple_r(self_data->geos_context, self_geom);
+    val = GEOSisSimple_r(self_data->geos_context, self_geom);
     if (val == 0) {
       result = Qfalse;
     }
@@ -354,13 +417,20 @@ static VALUE method_geometry_is_simple(VALUE self)
 
 static VALUE method_geometry_equals(VALUE self, VALUE rhs)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  GEOSContextHandle_t self_context;
+  char val;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_get_geos_geometry_safe(rhs);
+    rhs_geom = rgeo_get_geos_geometry_safe(rhs);
     if (rhs_geom) {
-      GEOSContextHandle_t self_context = self_data->geos_context;
+      self_context = self_data->geos_context;
       // GEOS has a bug where empty geometries are not spatially equal
       // to each other. Work around this case first.
       if (GEOSisEmpty_r(self_context, self_geom) == 1 &&
@@ -368,7 +438,7 @@ static VALUE method_geometry_equals(VALUE self, VALUE rhs)
         result = Qtrue;
       }
       else {
-        char val = GEOSEquals_r(self_context, self_geom, rhs_geom);
+        val = GEOSEquals_r(self_context, self_geom, rhs_geom);
         if (val == 0) {
           result = Qfalse;
         }
@@ -391,15 +461,23 @@ static VALUE method_geometry_eql(VALUE self, VALUE rhs)
 
 static VALUE method_geometry_disjoint(VALUE self, VALUE rhs)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+  const GEOSPreparedGeometry* prep;
+#endif
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      char val;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
-      const GEOSPreparedGeometry* prep = rgeo_request_prepared_geometry(self_data);
+      prep = rgeo_request_prepared_geometry(self_data);
       if (prep)
         val = GEOSPreparedDisjoint_r(self_data->geos_context, prep, rhs_geom);
       else
@@ -419,15 +497,23 @@ static VALUE method_geometry_disjoint(VALUE self, VALUE rhs)
 
 static VALUE method_geometry_intersects(VALUE self, VALUE rhs)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED1
+  const GEOSPreparedGeometry* prep;
+#endif
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      char val;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED1
-      const GEOSPreparedGeometry* prep = rgeo_request_prepared_geometry(self_data);
+      prep = rgeo_request_prepared_geometry(self_data);
       if (prep)
         val = GEOSPreparedIntersects_r(self_data->geos_context, prep, rhs_geom);
       else
@@ -447,15 +533,23 @@ static VALUE method_geometry_intersects(VALUE self, VALUE rhs)
 
 static VALUE method_geometry_touches(VALUE self, VALUE rhs)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+  const GEOSPreparedGeometry* prep;
+#endif
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      char val;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
-      const GEOSPreparedGeometry* prep = rgeo_request_prepared_geometry(self_data);
+      prep = rgeo_request_prepared_geometry(self_data);
       if (prep)
         val = GEOSPreparedTouches_r(self_data->geos_context, prep, rhs_geom);
       else
@@ -475,15 +569,23 @@ static VALUE method_geometry_touches(VALUE self, VALUE rhs)
 
 static VALUE method_geometry_crosses(VALUE self, VALUE rhs)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+  const GEOSPreparedGeometry* prep;
+#endif
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      char val;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
-      const GEOSPreparedGeometry* prep = rgeo_request_prepared_geometry(self_data);
+      prep = rgeo_request_prepared_geometry(self_data);
       if (prep)
         val = GEOSPreparedCrosses_r(self_data->geos_context, prep, rhs_geom);
       else
@@ -503,15 +605,23 @@ static VALUE method_geometry_crosses(VALUE self, VALUE rhs)
 
 static VALUE method_geometry_within(VALUE self, VALUE rhs)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+  const GEOSPreparedGeometry* prep;
+#endif
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      char val;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
-      const GEOSPreparedGeometry* prep = rgeo_request_prepared_geometry(self_data);
+      prep = rgeo_request_prepared_geometry(self_data);
       if (prep)
         val = GEOSPreparedWithin_r(self_data->geos_context, prep, rhs_geom);
       else
@@ -531,15 +641,23 @@ static VALUE method_geometry_within(VALUE self, VALUE rhs)
 
 static VALUE method_geometry_contains(VALUE self, VALUE rhs)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED1
+  const GEOSPreparedGeometry* prep;
+#endif
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      char val;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED1
-      const GEOSPreparedGeometry* prep = rgeo_request_prepared_geometry(self_data);
+      prep = rgeo_request_prepared_geometry(self_data);
       if (prep)
         val = GEOSPreparedContains_r(self_data->geos_context, prep, rhs_geom);
       else
@@ -559,15 +677,23 @@ static VALUE method_geometry_contains(VALUE self, VALUE rhs)
 
 static VALUE method_geometry_overlaps(VALUE self, VALUE rhs)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+#ifdef RGEO_GEOS_SUPPORTS_PREPARED2
+  const GEOSPreparedGeometry* prep;
+#endif
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      char val;
 #ifdef RGEO_GEOS_SUPPORTS_PREPARED2
-      const GEOSPreparedGeometry* prep = rgeo_request_prepared_geometry(self_data);
+      prep = rgeo_request_prepared_geometry(self_data);
       if (prep)
         val = GEOSPreparedOverlaps_r(self_data->geos_context, prep, rhs_geom);
       else
@@ -587,13 +713,19 @@ static VALUE method_geometry_overlaps(VALUE self, VALUE rhs)
 
 static VALUE method_geometry_relate(VALUE self, VALUE rhs, VALUE pattern)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  char val;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      char val = GEOSRelatePattern_r(self_data->geos_context, self_geom, rhs_geom, StringValuePtr(pattern));
+      val = GEOSRelatePattern_r(self_data->geos_context, self_geom, rhs_geom, StringValuePtr(pattern));
       if (val == 0) {
         result = Qfalse;
       }
@@ -608,13 +740,18 @@ static VALUE method_geometry_relate(VALUE self, VALUE rhs, VALUE pattern)
 
 static VALUE method_geometry_distance(VALUE self, VALUE rhs)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  const GEOSGeometry* rhs_geom;
+  double dist;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
+    rhs_geom = rgeo_convert_to_geos_geometry(self_data->factory, rhs, Qnil);
     if (rhs_geom) {
-      double dist;
       if (GEOSDistance_r(self_data->geos_context, self_geom, rhs_geom, &dist)) {
         result = rb_float_new(dist);
       }
@@ -626,12 +763,18 @@ static VALUE method_geometry_distance(VALUE self, VALUE rhs)
 
 static VALUE method_geometry_buffer(VALUE self, VALUE distance)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  VALUE factory;
+  int resolution;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    VALUE factory = self_data->factory;
-    int resolution = NUM2INT(RGEO_FACTORY_DATA_PTR(factory)->buffer_resolution);
+    factory = self_data->factory;
+    resolution = NUM2INT(RGEO_FACTORY_DATA_PTR(factory)->buffer_resolution);
     result = rgeo_wrap_geos_geometry(factory, GEOSBuffer_r(self_data->geos_context, self_geom, rb_num2dbl(distance), resolution), Qnil);
   }
   return result;
@@ -640,9 +783,13 @@ static VALUE method_geometry_buffer(VALUE self, VALUE distance)
 
 static VALUE method_geometry_convex_hull(VALUE self)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
     result = rgeo_wrap_geos_geometry(self_data->factory, GEOSConvexHull_r(self_data->geos_context, self_geom), Qnil);
   }
@@ -652,12 +799,18 @@ static VALUE method_geometry_convex_hull(VALUE self)
 
 static VALUE method_geometry_intersection(VALUE self, VALUE rhs)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  VALUE factory;
+  const GEOSGeometry* rhs_geom;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    VALUE factory = self_data->factory;
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
+    factory = self_data->factory;
+    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
     if (rhs_geom) {
       result = rgeo_wrap_geos_geometry(factory, GEOSIntersection_r(self_data->geos_context, self_geom, rhs_geom), Qnil);
     }
@@ -668,12 +821,18 @@ static VALUE method_geometry_intersection(VALUE self, VALUE rhs)
 
 static VALUE method_geometry_union(VALUE self, VALUE rhs)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  VALUE factory;
+  const GEOSGeometry* rhs_geom;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    VALUE factory = self_data->factory;
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
+    factory = self_data->factory;
+    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
     if (rhs_geom) {
       result = rgeo_wrap_geos_geometry(factory, GEOSUnion_r(self_data->geos_context, self_geom, rhs_geom), Qnil);
     }
@@ -684,12 +843,18 @@ static VALUE method_geometry_union(VALUE self, VALUE rhs)
 
 static VALUE method_geometry_difference(VALUE self, VALUE rhs)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  VALUE factory;
+  const GEOSGeometry* rhs_geom;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    VALUE factory = self_data->factory;
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
+    factory = self_data->factory;
+    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
     if (rhs_geom) {
       result = rgeo_wrap_geos_geometry(factory, GEOSDifference_r(self_data->geos_context, self_geom, rhs_geom), Qnil);
     }
@@ -700,12 +865,18 @@ static VALUE method_geometry_difference(VALUE self, VALUE rhs)
 
 static VALUE method_geometry_sym_difference(VALUE self, VALUE rhs)
 {
-  VALUE result = Qnil;
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
-  const GEOSGeometry* self_geom = self_data->geom;
+  VALUE result;
+  RGeo_GeometryData* self_data;
+  const GEOSGeometry* self_geom;
+  VALUE factory;
+  const GEOSGeometry* rhs_geom;
+
+  result = Qnil;
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_geom = self_data->geom;
   if (self_geom) {
-    VALUE factory = self_data->factory;
-    const GEOSGeometry* rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
+    factory = self_data->factory;
+    rhs_geom = rgeo_convert_to_geos_geometry(factory, rhs, Qnil);
     if (rhs_geom) {
       result = rgeo_wrap_geos_geometry(factory, GEOSSymDifference_r(self_data->geos_context, self_geom, rhs_geom), Qnil);
     }
@@ -722,13 +893,21 @@ static VALUE alloc_geometry(VALUE klass)
 
 static VALUE method_geometry_initialize_copy(VALUE self, VALUE orig)
 {
+  RGeo_GeometryData* self_data;
+  const GEOSPreparedGeometry* prep;
+  const GEOSGeometry* geom;
+  RGeo_GeometryData* orig_data;
+  GEOSContextHandle_t orig_context;
+  GEOSGeometry* clone_geom;
+  RGeo_FactoryData* factory_data;
+
   // Clear out any existing value
-  RGeo_GeometryData* self_data = RGEO_GEOMETRY_DATA_PTR(self);
+  self_data = RGEO_GEOMETRY_DATA_PTR(self);
   if (self_data->geom) {
     GEOSGeom_destroy_r(self_data->geos_context, self_data->geom);
     self_data->geom = NULL;
   }
-  const GEOSPreparedGeometry* prep = self_data->prep;
+  prep = self_data->prep;
   if (prep && prep != (GEOSPreparedGeometry*)1 && prep != (GEOSPreparedGeometry*)2) {
     GEOSPreparedGeom_destroy_r(self_data->geos_context, prep);
   }
@@ -738,13 +917,13 @@ static VALUE method_geometry_initialize_copy(VALUE self, VALUE orig)
   self_data->klasses = Qnil;
   
   // Copy value from orig
-  const GEOSGeometry* geom = rgeo_get_geos_geometry_safe(orig);
+  geom = rgeo_get_geos_geometry_safe(orig);
   if (geom) {
-    RGeo_GeometryData* orig_data = RGEO_GEOMETRY_DATA_PTR(orig);
-    GEOSContextHandle_t orig_context = orig_data->geos_context;
-    GEOSGeometry* clone_geom = GEOSGeom_clone_r(orig_context, geom);
+    orig_data = RGEO_GEOMETRY_DATA_PTR(orig);
+    orig_context = orig_data->geos_context;
+    clone_geom = GEOSGeom_clone_r(orig_context, geom);
     if (clone_geom) {
-      RGeo_FactoryData* factory_data = RGEO_FACTORY_DATA_PTR(orig_data->factory);
+      factory_data = RGEO_FACTORY_DATA_PTR(orig_data->factory);
       GEOSSetSRID_r(orig_context, clone_geom, GEOSGetSRID_r(orig_context, geom));
       self_data->geom = clone_geom;
       self_data->geos_context = orig_context;
@@ -763,7 +942,9 @@ static VALUE method_geometry_initialize_copy(VALUE self, VALUE orig)
 
 void rgeo_init_geos_geometry(RGeo_Globals* globals)
 {
-  VALUE geos_geometry_class = rb_define_class_under(globals->geos_module, "GeometryImpl", rb_cObject);
+  VALUE geos_geometry_class;
+
+  geos_geometry_class = rb_define_class_under(globals->geos_module, "GeometryImpl", rb_cObject);
   globals->geos_geometry = geos_geometry_class;
   globals->feature_geometry = rb_const_get_at(globals->feature_module, rb_intern("Geometry"));
   rb_funcall(globals->global_mixins, rb_intern("include_in_class"), 2,