ffi-geos 1.2.0 → 2.2.0

data/.travis.yml

@@ -1,17 +1,32 @@
 cache: bundler
 sudo: false
 language: ruby
+dist: trusty
+
 rvm:
-  - 2.4.0
-  - 2.3.3
-  - 2.2.6
-  - rbx-3
-  - jruby-19mode
-matrix:
-  allow_failures:
-    - rvm: rbx-3
-    - rvm: jruby-19mode
+  - '2.7'
+  - '2.6'
+  - '2.5'
+  - jruby-head
+
 addons:
   apt:
     packages:
       - libgeos-c1
+  sonarcloud:
+    organization: "dark-panda"
+    token:
+      secure: UiS3BU1SUSbIynvaup+3w9NNa85mH3lXSa+iCQx9luhp5Nc5Zg4xedycfGylCzpr6D6vRRH3gYefafitcvjS8LbhtNd2Z4oezp2T4fRt8W387HJ3wIcRkyOwBhmQqt/SiPiQr/rkDE9VomelLe7RSkelfAQQvpka5TMzc4wKYd4=
+
+git:
+  depth: false
+
+before_install:
+  - gem install bundler
+
+before_script:
+  - bundle exec rubocop --format=json > rubocop-report.json || true
+
+script:
+  - bundle exec rake test
+  - sonar-scanner

data/FUNDING.yml

@@ -0,0 +1,2 @@
+github:
+  - dark-panda

data/Gemfile

@@ -1,25 +1,21 @@
+# frozen_string_literal: true
+
 source 'https://rubygems.org'
 
 gemspec
 
-gem "rdoc", "~> 3.12"
-gem "rake", "~> 10.0"
-gem "minitest"
-gem "minitest-reporters"
+gem 'guard'
+gem 'guard-minitest'
+gem 'minitest'
+gem 'minitest-reporters'
+gem 'rake'
+gem 'rdoc'
+gem 'rubocop', require: false
+gem 'simplecov', '~> 0.17.0', require: false
 
 platforms :rbx do
-  gem 'rubysl', '~> 2.0'
   gem 'rubinius-developer_tools'
+  gem 'rubysl', '~> 2.0'
 end
 
-
-if RUBY_VERSION >= '1.9'
-  gem "simplecov"
-  gem "guard"
-  gem 'guard-minitest'
-end
-
-if File.exists?('Gemfile.local')
-  instance_eval File.read('Gemfile.local')
-end
-
+instance_eval File.read('Gemfile.local') if File.exist?('Gemfile.local')

data/Guardfile

@@ -1,17 +1,15 @@
+# frozen_string_literal: true
 
-guard 'minitest', :test_folders => 'test', :test_file_patterns => '*_tests.rb' do
-  watch(%r|^test/(.+)_tests\.rb|)
+guard 'minitest', test_folders: 'test', test_file_patterns: '*_tests.rb' do
+  watch(%r{^test/(.+)_tests\.rb})
 
   watch(%r{^lib/(.*/)?([^/]+)\.rb$}) do |m|
     "test/#{m[2]}_tests.rb"
   end
 
-  watch(%r|^test/test_helper\.rb|) do
-    "test"
+  watch(%r{^test/test_helper\.rb}) do
+    'test'
   end
 end
 
-if File.exists?('Guardfile.local')
-  instance_eval File.read('Guardfile.local')
-end
-
+instance_eval File.read('Guardfile.local') if File.exist?('Guardfile.local')

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2010-2017 J Smith <dark.panda@gmail.com>
+Copyright (c) 2010-2021 J Smith <dark.panda@gmail.com>
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/README.rdoc

@@ -7,15 +7,8 @@
 * GEOS version 3.3.0 or greater. GEOS 3.2.2 and below will work to an extent,
   but some features and methods will be disabled or missing.
 
-Ruby versions known to work according to travis-ci and local testing:
-
-* Ruby MRI 1.9.3, 2.0+, 2.1+, 2.2+
-* Ruby MRI 1.8.7 works but as Ruby 1.8 is no longer being maintained, there's
-  no guarantee this will continue in the future and is therefore no longer
-  being tested with the same rigour as more modern versions of Ruby.
-* Rubinius 2
-* JRuby 1.6+, with the exception of versions of JRuby prior to 1.6.3 as per
-  below. This includes both 1.8 and 1.9 modes.
+We currently test on Travis CI using the current releases of MRI that are
+maintained. See `.travis.yml` for a list. We also test against jruby-head.
 
 === JRuby Notes
 
@@ -74,17 +67,6 @@ Ruby bindings along with the following enhancements and additions:
   entire GEOS C API is represented in ffi-geos along with all sorts of useful
   convenience methods and geometry conversion and manipulation methods.
 
-* *NEW IN ffi-geos 1.0.0* -- all errors thrown by ffi-geos are now instances of
-  Geos::Error or subclasses thereof. Geos::Error itself is a descendant
-  of RuntimeError as is the case with the native Geos extension. This means
-  that code like rescue RuntimeError should still work but you can now
-  further capture more precise error types by capturing errors like
-  Geos::Error, Geos::ParseError, etc.
-
-* *NEW IN ffi-geos 1.0.0* -- new methods for Geom::Geometry#voronoi_diagram,
-  Geos::MultiLineString#closed? and Geos::Geometry#clip_by_rect when using
-  GEOS 3.5.0+.
-
 == Thanks
 
 * Daniel Azuma for the testing and JRuby help.

data/Rakefile

@@ -1,3 +1,4 @@
+# frozen_string_literal: true
 
 # -*- ruby -*-
 
@@ -7,18 +8,19 @@ require 'rake/testtask'
 require 'rdoc/task'
 require 'bundler/gem_tasks'
 
-$:.push File.expand_path(File.dirname(__FILE__), 'lib')
+$LOAD_PATH.push File.expand_path(File.dirname(__FILE__), 'lib')
 
 version = Geos::VERSION
 
 desc 'Test GEOS interface'
 Rake::TestTask.new(:test) do |t|
+  t.libs << "#{File.dirname(__FILE__)}/test"
   t.test_files = FileList['test/**/*_tests.rb']
   t.verbose = !!ENV['VERBOSE_TESTS']
   t.warning = !!ENV['WARNINGS']
 end
 
-task :default => :test
+task default: :test
 
 begin
   desc 'Build docs'

data/ffi-geos.gemspec

@@ -1,26 +1,25 @@
-# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 
-require File.expand_path('../lib/ffi-geos/version', __FILE__)
+require File.expand_path('lib/ffi-geos/version', __dir__)
 
 Gem::Specification.new do |s|
-  s.name = "ffi-geos"
+  s.name = 'ffi-geos'
   s.version = Geos::VERSION
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["J Smith"]
-  s.description = "An ffi wrapper for GEOS, a C++ port of the Java Topology Suite (JTS)."
+  s.required_rubygems_version = Gem::Requirement.new('>= 0') if s.respond_to? :required_rubygems_version=
+  s.authors = ['J Smith']
+  s.description = 'An ffi wrapper for GEOS, a C++ port of the Java Topology Suite (JTS).'
   s.summary = s.description
-  s.email = "dark.panda@gmail.com"
-  s.license = "MIT"
+  s.email = 'dark.panda@gmail.com'
+  s.license = 'MIT'
   s.extra_rdoc_files = [
-    "README.rdoc"
+    'README.rdoc'
   ]
-  s.files = `git ls-files`.split($\)
+  s.files = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
   s.executables = s.files.grep(%r{^bin/}).map { |f| File.basename(f) }
   s.test_files = s.files.grep(%r{^(test|spec|features)/})
-  s.homepage = "http://github.com/dark-panda/ffi-geos"
-  s.require_paths = ["lib"]
+  s.homepage = 'http://github.com/dark-panda/ffi-geos'
+  s.require_paths = ['lib']
 
-  s.add_dependency("ffi", [">= 1.0.0"])
+  s.add_dependency('ffi', ['>= 1.0.0'])
 end
-

data/lib/ffi-geos.rb

@@ -1,4 +1,3 @@
-# encoding: UTF-8
 # frozen_string_literal: true
 
 require 'ffi'
@@ -51,38 +50,36 @@ module Geos
 
   module FFIGeos
     def self.search_paths
-      @search_paths ||= begin
+      @search_paths ||= \
         if ENV['GEOS_LIBRARY_PATH']
-          [ ENV['GEOS_LIBRARY_PATH'] ]
+          [ENV['GEOS_LIBRARY_PATH']]
         elsif FFI::Platform::IS_WINDOWS
           ENV['PATH'].split(File::PATH_SEPARATOR)
         else
-          [ '/usr/local/{lib64,lib}', '/opt/local/{lib64,lib}', '/usr/{lib64,lib}', '/usr/lib/{x86_64,i386}-linux-gnu' ]
+          ['/usr/local/{lib64,lib}', '/opt/local/{lib64,lib}', '/usr/{lib64,lib}', '/usr/lib/{x86_64,i386}-linux-gnu']
         end
-      end
     end
 
     def self.find_lib(lib)
       if ENV['GEOS_LIBRARY_PATH'] && File.file?(ENV['GEOS_LIBRARY_PATH'])
         ENV['GEOS_LIBRARY_PATH']
       else
-        Dir.glob(search_paths.map { |path|
+        Dir.glob(search_paths.map do |path|
           File.expand_path(File.join(path, "#{lib}.#{FFI::Platform::LIBSUFFIX}{,.?}"))
-        }).first
+        end).first
       end
     end
 
     def self.geos_library_path
-      @geos_library_path ||= begin
+      @geos_library_path ||= \
         # On MingW the libraries have version numbers
         find_lib('{lib,}geos_c{,-?}')
-      end
     end
 
     # For backwards compatibility with older ffi-geos versions where this
     # used to return an Array.
     def self.geos_library_paths
-      [ self.geos_library_path ]
+      [geos_library_path]
     end
 
     extend ::FFI::Library
@@ -147,896 +144,1000 @@ module Geos
       # Initialization and cleanup
 
       # deprecated in GEOS 3.5.0+
-      :initGEOS_r => [
+      initGEOS_r: [
         :pointer,
 
         # notice callback
-        callback([ :string, :string ], :void),
+        callback([:string, :string], :void),
 
         # error callback
-        callback([ :string, :string ], :void)
+        callback([:string, :string], :void)
       ],
 
-      :finishGEOS_r => [
+      finishGEOS_r: [
         # void, *handle
         :void, :pointer
       ],
       # / deprecated in GEOS 3.5.0+
 
       # GEOS 3.5.0+
-      :GEOS_init_r => [ :pointer ],
+      GEOS_init_r: [:pointer],
 
-      :GEOSContext_setNoticeMessageHandler_r => [
+      GEOSContext_setNoticeMessageHandler_r: [
         # void, *handle, callback, *void
-        :void, :pointer, callback([ :string, :string ], :void), :pointer
+        :void, :pointer, callback([:string, :string], :void), :pointer
       ],
 
-      :GEOSContext_setErrorMessageHandler_r => [
+      GEOSContext_setErrorMessageHandler_r: [
         # void, *handle, callback, *void
-        :void, :pointer, callback([ :string, :string ], :void), :pointer
+        :void, :pointer, callback([:string, :string], :void), :pointer
       ],
 
-      :GEOS_finish_r => [
+      GEOS_finish_r: [
         # void, *handle
         :void, :pointer
       ],
       # / GEOS 3.5.0+
 
-      :GEOS_interruptRegisterCallback => [
+      GEOS_interruptRegisterCallback: [
         :pointer,
         callback([], :void)
       ],
 
-      :GEOS_interruptRequest => [
+      GEOS_interruptRequest: [
         :void
       ],
 
-      :GEOS_interruptCancel => [
+      GEOS_interruptCancel: [
         :void
       ],
 
-      :GEOSversion => [
+      GEOSversion: [
         :string
       ],
 
-      :GEOSjtsport => [
+      GEOSjtsport: [
         :string
       ],
 
-      :GEOSPolygonize_r => [
+      GEOSPolygonize_r: [
         # *geom, *handle, **geoms, ngeoms
         :pointer, :pointer, :pointer, :uint
       ],
 
-      :GEOSPolygonizer_getCutEdges_r => [
+      GEOSPolygonize_valid_r: [
         # *geom, *handle, **geoms, ngeoms
         :pointer, :pointer, :pointer, :uint
       ],
 
-      :GEOSPolygonize_full_r => [
+      GEOSBuildArea_r: [
+        # *geom, *handle, *geom
+        :pointer, :pointer, :pointer
+      ],
+
+      GEOSMakeValid_r: [
+        # *geom, *handle, *geom
+        :pointer, :pointer, :pointer
+      ],
+
+      GEOSPolygonizer_getCutEdges_r: [
+        # *geom, *handle, **geoms, ngeoms
+        :pointer, :pointer, :pointer, :uint
+      ],
+
+      GEOSPolygonize_full_r: [
         # *geom, *handle, *geom, **cuts, **dangles, **invalid
         :pointer, :pointer, :pointer, :pointer, :pointer, :pointer
       ],
 
-      :GEOSGeom_createPoint_r => [
+      GEOSGeom_createPoint_r: [
         # *geom, *handle, *coord_seq
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSGeom_createEmptyPoint_r => [
+      GEOSGeom_createEmptyPoint_r: [
         # *geom, *handle
         :pointer, :pointer
       ],
 
-      :GEOSGeom_createEmptyLineString_r => [
+      GEOSGeom_createEmptyLineString_r: [
         # *geom, *handle
         :pointer, :pointer
       ],
 
-      :GEOSGeom_createLinearRing_r => [
+      GEOSGeom_createLinearRing_r: [
         # *geom, *handle, *coord_seq
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSGeom_createLineString_r => [
+      GEOSGeom_createLineString_r: [
         # *geom, *handle, *coord_seq
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSGeom_createPolygon_r => [
+      GEOSGeom_createPolygon_r: [
         # *geom, *handle, *geom, **holes, nholes
         :pointer, :pointer, :pointer, :pointer, :uint
       ],
 
-      :GEOSGeom_createEmptyPolygon_r => [
+      GEOSGeom_createEmptyPolygon_r: [
         # *geom, *handle
         :pointer, :pointer
       ],
 
-      :GEOSGeom_createCollection_r => [
+      GEOSGeom_createCollection_r: [
         # *geom, *handle, type, **geoms, ngeoms
         :pointer, :pointer, :geometry_type, :pointer, :uint
       ],
 
-      :GEOSGeom_createEmptyCollection_r => [
+      GEOSGeom_createEmptyCollection_r: [
         # *geom, *handle, type
         :pointer, :pointer, :geometry_type
       ],
       #### /Utility functions ####
 
       #### CoordinateSequence functions ####
-      :GEOSCoordSeq_create_r => [
+      GEOSCoordSeq_create_r: [
         # *coord_seq, *handle, size, dims
         :pointer, :pointer, :uint, :uint
       ],
 
-      :GEOSCoordSeq_destroy_r => [
+      GEOSCoordSeq_destroy_r: [
         # void, *handle, *coord_seq
         :void, :pointer, :pointer
       ],
 
-      :GEOSCoordSeq_clone_r => [
+      GEOSCoordSeq_clone_r: [
         # *coord_seq, *handle, *coord_seq
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSCoordSeq_setX_r => [
+      GEOSCoordSeq_setX_r: [
         # 0 on exception, *handle, *coord_seq, idx, val
         :int, :pointer, :pointer, :uint, :double
       ],
 
-      :GEOSCoordSeq_setY_r => [
+      GEOSCoordSeq_setY_r: [
         # 0 on exception, *handle, *coord_seq, idx, val
         :int, :pointer, :pointer, :uint, :double
       ],
 
-      :GEOSCoordSeq_setZ_r => [
+      GEOSCoordSeq_setZ_r: [
         # 0 on exception, *handle, *coord_seq, idx, val
         :int, :pointer, :pointer, :uint, :double
       ],
 
-      :GEOSCoordSeq_setOrdinate_r => [
+      GEOSCoordSeq_setOrdinate_r: [
         # 0 on exception, *handle, *coord_seq, idx, dim, val
         :int, :pointer, :pointer, :uint, :uint, :double
       ],
 
-      :GEOSCoordSeq_getX_r => [
+      GEOSCoordSeq_getX_r: [
         # 0 on exception, *handle, *coord_seq, idx, (double *) val
         :int, :pointer, :pointer, :uint, :pointer
       ],
 
-      :GEOSCoordSeq_getY_r => [
+      GEOSCoordSeq_getY_r: [
         # 0 on exception, *handle, *coord_seq, idx, (double *) val
         :int, :pointer, :pointer, :uint, :pointer
       ],
 
-      :GEOSCoordSeq_getZ_r => [
+      GEOSCoordSeq_getZ_r: [
         # 0 on exception, *handle, *coord_seq, idx, (double *) val
         :int, :pointer, :pointer, :uint, :pointer
       ],
 
-      :GEOSCoordSeq_getOrdinate_r => [
+      GEOSCoordSeq_getOrdinate_r: [
         # 0 on exception, *handle, *coord_seq, idx, dim, (double *) val
         :int, :pointer, :pointer, :uint, :uint, :pointer
       ],
 
-      :GEOSCoordSeq_getSize_r => [
+      GEOSCoordSeq_getSize_r: [
         # 0 on exception, *handle, *coord_seq, (uint *) size
         :int, :pointer, :pointer, :pointer
       ],
 
-      :GEOSCoordSeq_getDimensions_r => [
+      GEOSCoordSeq_getDimensions_r: [
         # 0 on exception, *handle, *coord_seq, (uint *) size
         :int, :pointer, :pointer, :pointer
       ],
+
+      GEOSCoordSeq_isCCW_r: [
+        # 0 on exception, *handle, *coord_seq, (char *) value
+        :int, :pointer, :pointer, :pointer
+      ],
       #### /CoordinateSequence functions ####
 
       #### Geometry functions ####
-      :GEOSGeom_destroy_r => [
+      GEOSGeom_destroy_r: [
         # void, *handle, *geom
         :void, :pointer, :pointer
       ],
 
-      :GEOSGeom_clone_r => [
+      GEOSGeom_clone_r: [
         # *geom, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSGeomTypeId_r => [
+      GEOSGeomTypeId_r: [
         # type, *handle, *geom
         :int, :pointer, :pointer
       ],
 
-      :GEOSGeomType_r => [
+      GEOSGeomType_r: [
         # type, *handle, *geom
         :string, :pointer, :pointer
       ],
 
-      :GEOSGetSRID_r => [
+      GEOSGetSRID_r: [
         # srid, *handle, *geom
         :int, :pointer, :pointer
       ],
 
-      :GEOSSetSRID_r => [
+      GEOSSetSRID_r: [
         # void, *handle, *geom, srid
         :void, :pointer, :pointer, :int
       ],
 
-      :GEOSGeom_getDimensions_r => [
+      GEOSGeom_getDimensions_r: [
         # dims, *handle, *geom
         :int, :pointer, :pointer
       ],
 
-      :GEOSGetNumGeometries_r => [
+      GEOSGetNumGeometries_r: [
         # ngeoms, *handle, *geom
         :int, :pointer, :pointer
       ],
 
-      :GEOSGetNumCoordinates_r => [
+      GEOSGetNumCoordinates_r: [
         # numcoords, *handle, *geom
         :int, :pointer, :pointer
       ],
 
-      :GEOSGeom_getCoordSeq_r => [
+      GEOSGeom_getCoordSeq_r: [
         # *coord_seq, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSIntersection_r => [
+      GEOSIntersection_r: [
         # *geom, *handle, *geom_a, *geom_b
         :pointer, :pointer, :pointer, :pointer
       ],
 
-      :GEOSBufferWithParams_r => [
+      GEOSIntersectionPrec_r: [
+        # *geom, *handle, *geom_a, *geom_b, precision
+        :pointer, :pointer, :pointer, :pointer, :double
+      ],
+
+      GEOSBufferWithParams_r: [
         # *geom, *handle, *geom, *params, width
         :pointer, :pointer, :pointer, :pointer, :double
       ],
 
-      :GEOSBuffer_r => [
+      GEOSBuffer_r: [
         # *geom, *handle, *geom, width, quad_segs
         :pointer, :pointer, :pointer, :double, :int
       ],
 
-      :GEOSBufferWithStyle_r => [
+      GEOSBufferWithStyle_r: [
         # *geom, *handle, *geom, width, quad_segs, buffer_cap_style, buffer_join_style, mitre_limit
         :pointer, :pointer, :pointer, :double, :int, :buffer_cap_style, :buffer_join_style, :double
       ],
 
       # Deprecated in GEOS 3.3.0.
-      :GEOSSingleSidedBuffer_r => [
+      GEOSSingleSidedBuffer_r: [
         # *geom, *handle, *geom, width, quad_segs, buffer_join_style, mitre_limit, is_left
         :pointer, :pointer, :pointer, :double, :int, :buffer_join_style, :double, :int
       ],
 
-      :GEOSOffsetCurve_r => [
+      GEOSOffsetCurve_r: [
         # *geom, *handle, *geom, width, quad_segs, buffer_join_style, mitre_limit
         :pointer, :pointer, :pointer, :double, :int, :buffer_join_style, :double
       ],
 
-      :GEOSConvexHull_r => [
+      GEOSConvexHull_r: [
         # *geom, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSDifference_r => [
+      GEOSDifference_r: [
         # *geom, *handle, *geom_a, *geom_b
         :pointer, :pointer, :pointer, :pointer
       ],
 
-      :GEOSSymDifference_r => [
+      GEOSDifferencePrec_r: [
+        # *geom, *handle, *geom_a, *geom_b, precision
+        :pointer, :pointer, :pointer, :pointer, :double
+      ],
+
+      GEOSSymDifference_r: [
         # *geom, *handle, *geom_a, *geom_b
         :pointer, :pointer, :pointer, :pointer
       ],
 
-      :GEOSBoundary_r => [
+      GEOSSymDifferencePrec_r: [
+        # *geom, *handle, *geom_a, *geom_b, precision
+        :pointer, :pointer, :pointer, :pointer, :double
+      ],
+
+      GEOSBoundary_r: [
         # *geom, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSUnion_r => [
+      GEOSUnion_r: [
         # *geom, *handle, *geom_a, *geom_b
         :pointer, :pointer, :pointer, :pointer
       ],
 
-      :GEOSUnaryUnion_r => [
+      GEOSUnionPrec_r: [
+        # *geom, *handle, *geom_a, *geom_b, precision
+        :pointer, :pointer, :pointer, :pointer, :double
+      ],
+
+      GEOSCoverageUnion_r: [
         # *geom, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSNode_r => [
+      GEOSUnaryUnion_r: [
+        # *geom, *handle, *geom
+        :pointer, :pointer, :pointer
+      ],
+
+      GEOSUnaryUnionPrec_r: [
+        # *geom, *handle, *geom, precision
+        :pointer, :pointer, :pointer, :double
+      ],
+
+      GEOSNode_r: [
         # *geom, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
       # Deprecated in GEOS 3.3.0. Use GEOSUnaryUnion_r instead.
-      :GEOSUnionCascaded_r => [
+      GEOSUnionCascaded_r: [
         # *geom, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSPointOnSurface_r => [
+      GEOSPointOnSurface_r: [
         # *geom, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSClipByRect_r => [
+      GEOSClipByRect_r: [
         # *geom, *handle, *geom, xmin, ymin, xmax, ymax
         :pointer, :pointer, :pointer, :double, :double, :double, :double
       ],
 
-      :GEOSGetCentroid_r => [
+      GEOSGetCentroid_r: [
         # *geom, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSEnvelope_r => [
+      GEOSMinimumBoundingCircle_r: [
+        # *geom, *handle, *geom, *double radius, **geom center
+        :pointer, :pointer, :pointer, :pointer, :pointer
+      ],
+
+      GEOSEnvelope_r: [
         # *geom, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSLineMerge_r => [
+      GEOSLineMerge_r: [
         # *geom, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSSimplify_r => [
+      GEOSGeom_getXMin_r: [
+        # 0 on exception, *handle, (double *) value
+        :int, :pointer, :pointer, :pointer
+      ],
+
+      GEOSGeom_getXMax_r: [
+        # 0 on exception, *handle, (double *) value
+        :int, :pointer, :pointer, :pointer
+      ],
+
+      GEOSGeom_getYMin_r: [
+        # 0 on exception, *handle, (double *) value
+        :int, :pointer, :pointer, :pointer
+      ],
+
+      GEOSGeom_getYMax_r: [
+        # 0 on exception, *handle, (double *) value
+        :int, :pointer, :pointer, :pointer
+      ],
+
+      GEOSSimplify_r: [
         # *geom, *handle, *geom, tolerance
         :pointer, :pointer, :pointer, :double
       ],
 
-      :GEOSTopologyPreserveSimplify_r => [
+      GEOSTopologyPreserveSimplify_r: [
         # *geom, *handle, *geom, tolerance
         :pointer, :pointer, :pointer, :double
       ],
 
-      :GEOSGeom_extractUniquePoints_r => [
+      GEOSGeom_extractUniquePoints_r: [
         # *geom, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSSharedPaths_r => [
+      GEOSSharedPaths_r: [
         # *geom, *handle, *geom_a, *geom_b
         :pointer, :pointer, :pointer, :pointer
       ],
 
-      :GEOSSnap_r => [
+      GEOSSnap_r: [
         # *geom, *handle, *geom_a, *geom_b, tolerance
         :pointer, :pointer, :pointer, :pointer, :double
       ],
 
-      :GEOSDelaunayTriangulation_r => [
+      GEOSDelaunayTriangulation_r: [
         # *geom, *handle, *geom, tolerance, only_edges
         :pointer, :pointer, :pointer, :double, :int
       ],
 
-      :GEOSVoronoiDiagram_r => [
+      GEOSVoronoiDiagram_r: [
         # *geom, *handle, *geom, *envelope, tolerance, only_edges
         :pointer, :pointer, :pointer, :pointer, :double, :int
       ],
 
-      :GEOSRelate_r => [
+      GEOSRelate_r: [
         # string, *handle, *geom_a, *geom_b
         :string, :pointer, :pointer, :pointer
       ],
 
-      :GEOSRelatePatternMatch_r => [
+      GEOSRelatePatternMatch_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, pattern_a, pattern_b
         :char, :pointer, :string, :string
       ],
 
-      :GEOSRelatePattern_r => [
+      GEOSRelatePattern_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom_a, *geom_b, pattern
         :char, :pointer, :pointer, :pointer, :string
       ],
 
-      :GEOSRelateBoundaryNodeRule_r => [
+      GEOSRelateBoundaryNodeRule_r: [
         # string, *handle, *geom_a, *geom_b, bnr
         :string, :pointer, :pointer, :pointer, :relate_boundary_node_rule
       ],
 
-      :GEOSDisjoint_r => [
+      GEOSDisjoint_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom_a, *geom_b
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSTouches_r => [
+      GEOSTouches_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom_a, *geom_b
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSIntersects_r => [
+      GEOSIntersects_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom_a, *geom_b
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSCrosses_r => [
+      GEOSCrosses_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom_a, *geom_b
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSWithin_r => [
+      GEOSWithin_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom_a, *geom_b
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSContains_r => [
+      GEOSContains_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom_a, *geom_b
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSOverlaps_r => [
+      GEOSOverlaps_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom_a, *geom_b
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSCovers_r => [
+      GEOSCovers_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom_a, *geom_b
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSCoveredBy_r => [
+      GEOSCoveredBy_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom_a, *geom_b
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSEquals_r => [
+      GEOSEquals_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom_a, *geom_b
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSEqualsExact_r => [
+      GEOSEqualsExact_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom_a, *geom_b
         :char, :pointer, :pointer, :pointer, :double
       ],
 
-      :GEOSisEmpty_r => [
+      GEOSisEmpty_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom
         :char, :pointer, :pointer
       ],
 
-      :GEOSisValid_r => [
+      GEOSisValid_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom
         :char, :pointer, :pointer
       ],
 
-      :GEOSisValidReason_r => [
+      GEOSisValidReason_r: [
         # reason, *handle, *geom
         :string, :pointer, :pointer
       ],
 
-      :GEOSisValidDetail_r => [
+      GEOSisValidDetail_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom, flags, (string**) reasons, **geoms
         :char, :pointer, :pointer, :int, :pointer, :pointer
       ],
 
-      :GEOSisSimple_r => [
+      GEOSisSimple_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom
         :char, :pointer, :pointer
       ],
 
-      :GEOSisRing_r => [
+      GEOSisRing_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom
         :char, :pointer, :pointer
       ],
 
-      :GEOSHasZ_r => [
+      GEOSHasZ_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom
         :char, :pointer, :pointer
       ],
 
-      :GEOSisClosed_r => [
+      GEOSisClosed_r: [
         # (2 on exception, 1 on true, 2 on false), *handle, *geom
         :char, :pointer, :pointer
       ],
 
-      :GEOSArea_r => [
+      GEOSArea_r: [
         # (0 on exception, 1 otherwise), *handle, *geom, (double *) area
         :int, :pointer, :pointer, :pointer
       ],
 
-      :GEOSLength_r => [
+      GEOSLength_r: [
         # (0 on exception, 1 otherwise), *handle, *geom, (double *) length
         :int, :pointer, :pointer, :pointer
       ],
 
-      :GEOSDistance_r => [
+      GEOSDistance_r: [
         # (0 on exception, 1 otherwise), *handle, *geom_a, *geom_b, (double *) distance
         :int, :pointer, :pointer, :pointer, :pointer
       ],
 
-      :GEOSHausdorffDistance_r => [
+      GEOSDistanceIndexed_r: [
         # (0 on exception, 1 otherwise), *handle, *geom_a, *geom_b, (double *) distance
         :int, :pointer, :pointer, :pointer, :pointer
       ],
 
-      :GEOSHausdorffDistanceDensify_r => [
+      GEOSHausdorffDistance_r: [
+        # (0 on exception, 1 otherwise), *handle, *geom_a, *geom_b, (double *) distance
+        :int, :pointer, :pointer, :pointer, :pointer
+      ],
+
+      GEOSHausdorffDistanceDensify_r: [
         # (0 on exception, 1 otherwise), *handle, *geom_a, *geom_b, densifyFrac, (double *) distance
         :int, :pointer, :pointer, :pointer, :double, :pointer
       ],
 
-      :GEOSNearestPoints_r => [
+      GEOSNearestPoints_r: [
         # (NULL on exception, pointer to CoordinateSequence otherwise), *handle, *geom, *geom
         :pointer, :pointer, :pointer, :pointer
       ],
 
-      :GEOSGetGeometryN_r => [
+      GEOSGetGeometryN_r: [
         # *geom, *handle, *geom, n
         :pointer, :pointer, :pointer, :int
       ],
 
-      :GEOSGetNumInteriorRings_r => [
+      GEOSGetNumInteriorRings_r: [
         # rings, *handle, *geom
         :int, :pointer, :pointer
       ],
 
-      :GEOSNormalize_r => [
+      GEOSNormalize_r: [
         # -1 on exception, *handle, *geom
         :int, :pointer, :pointer
       ],
 
-      :GEOSGetInteriorRingN_r => [
+      GEOSGetInteriorRingN_r: [
         # *geom, *handle, *geom, n
         :pointer, :pointer, :pointer, :int
       ],
 
-      :GEOSGetExteriorRing_r => [
+      GEOSGetExteriorRing_r: [
         # *geom, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSGeomGetNumPoints_r => [
+      GEOSGeomGetNumPoints_r: [
         # numpoints, *handle, *geom
         :int, :pointer, :pointer
       ],
 
-      :GEOSGeomGetX_r => [
+      GEOSGeomGetX_r: [
         # -1 on exception, *handle, *geom, *point
         :int, :pointer, :pointer, :pointer
       ],
 
-      :GEOSGeomGetY_r => [
+      GEOSGeomGetY_r: [
         # -1 on exception, *handle, *geom, *point
         :int, :pointer, :pointer, :pointer
       ],
 
-      :GEOSGeomGetZ_r => [
+      GEOSGeomGetZ_r: [
         # -1 on exception, *handle, *geom, *point
         :int, :pointer, :pointer, :pointer
       ],
 
-      :GEOSGeomGetPointN_r => [
+      GEOSGeomGetPointN_r: [
         # *point, *handle, *geom, n
         :pointer, :pointer, :pointer, :int
       ],
 
-      :GEOSGeomGetStartPoint_r => [
+      GEOSGeomGetStartPoint_r: [
         # *point, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSGeomGetEndPoint_r => [
+      GEOSGeomGetEndPoint_r: [
         # *point, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSGeom_setPrecision_r => [
+      GEOSGeom_setPrecision_r: [
         # *geom, *hande, *geom, grid_size, int flags
         :pointer, :pointer, :pointer, :double, :int
       ],
 
-      :GEOSGeom_getPrecision_r => [
+      GEOSGeom_getPrecision_r: [
         # precision, *hande, *geom
         :double, :pointer, :pointer
       ],
 
-      :GEOSMinimumRotatedRectangle_r => [
+      GEOSMinimumRotatedRectangle_r: [
         # *geom, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSMinimumClearance_r => [
+      GEOSMinimumClearance_r: [
         # 0 on success, *handle, *geom, *clearance
         :int, :pointer, :pointer, :pointer
       ],
 
-      :GEOSMinimumClearanceLine_r => [
+      GEOSMinimumClearanceLine_r: [
         # *geom, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSMinimumWidth_r => [
+      GEOSMaximumInscribedCircle_r: [
+        # *geom, *handle, *geom, tolerance
+        :pointer, :pointer, :pointer, :double
+      ],
+
+      GEOSLargestEmptyCircle_r: [
+        # *geom, *handle, *geom, *geom, tolerance
+        :pointer, :pointer, :pointer, :pointer, :double
+      ],
+
+      GEOSMinimumWidth_r: [
         # *geom, *handle, *geom
         :pointer, :pointer, :pointer
       ],
+
+      GEOSReverse_r: [
+        # *geom, *handle, *geom
+        :pointer, :pointer, :pointer
+      ],
+
+      GEOSFrechetDistance_r: [
+        # (0 on exception, 1 otherwise), *handle, *geom_a, *geom_b, (double *) distance
+        :int, :pointer, :pointer, :pointer, :pointer
+      ],
+
+      GEOSFrechetDistanceDensify_r: [
+        # (0 on exception, 1 otherwise), *handle, *geom_a, *geom_b, densifyFrac, (double *) distance
+        :int, :pointer, :pointer, :pointer, :double, :pointer
+      ],
       #### /Geometry functions ####
 
       #### STRtree functions ####
-      :GEOSSTRtree_create_r => [
+      GEOSSTRtree_create_r: [
         # *tree, *handle, node_capacity
         :pointer, :pointer, :size_t
       ],
 
-      :GEOSSTRtree_insert_r => [
+      GEOSSTRtree_insert_r: [
         # void, *handle, *tree, *geom, *void
         :void, :pointer, :pointer, :pointer, :pointer
       ],
 
-      :GEOSSTRtree_query_r => [
+      GEOSSTRtree_query_r: [
         # void, *handle, *tree, *geom, void query_callback((void *) item, (void *) user_data), (void *) user_data
-        :void, :pointer, :pointer, :pointer, callback([ :pointer, :pointer ], :void), :pointer
+        :void, :pointer, :pointer, :pointer, callback([:pointer, :pointer], :void), :pointer
       ],
 
-      :GEOSSTRtree_iterate_r => [
+      GEOSSTRtree_iterate_r: [
         # void, *handle, *tree, void query_callback((void *) item, (void *) user_data), (void *) user_data
-        :void, :pointer, :pointer, callback([ :pointer, :pointer ], :void), :pointer
+        :void, :pointer, :pointer, callback([:pointer, :pointer], :void), :pointer
       ],
 
-      :GEOSSTRtree_remove_r => [
+      GEOSSTRtree_remove_r: [
         # bool, *handle, *tree, *geom, (void *) item
         :char, :pointer, :pointer, :pointer, :pointer
       ],
 
-      :GEOSSTRtree_destroy_r => [
+      GEOSSTRtree_destroy_r: [
         # void, *handle, *tree
         :void, :pointer, :pointer
       ],
 
-      :GEOSSTRtree_nearest_generic_r => [
+      GEOSSTRtree_nearest_generic_r: [
         # *void, *handle, *tree, *item, *item_envelope, int distance_callback(*item_1, *item_2, *double, void *user_data), *user_data
-        :pointer, :pointer, :pointer, :pointer, :pointer, callback([ :pointer, :pointer, :pointer, :pointer ], :int), :pointer
+        :pointer, :pointer, :pointer, :pointer, :pointer, callback([:pointer, :pointer, :pointer, :pointer], :int), :pointer
       ],
       #### /STRtree functions ####
 
       #### PreparedGeometry functions ####
-      :GEOSPrepare_r => [
+      GEOSPrepare_r: [
         # *prepared, *handle, *geom
         :pointer, :pointer, :pointer
       ],
 
-      :GEOSPreparedGeom_destroy_r => [
+      GEOSPreparedGeom_destroy_r: [
         # void, *handle, *geom
         :void, :pointer, :pointer
       ],
 
-      :GEOSPreparedContains_r => [
+      GEOSPreparedContains_r: [
         # (2 on exception, 1 on true, 0 on false), *handle, *prepared, *geom
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSPreparedContainsProperly_r => [
+      GEOSPreparedContainsProperly_r: [
         # (2 on exception, 1 on true, 0 on false), *handle, *prepared, *geom
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSPreparedCoveredBy_r => [
+      GEOSPreparedCoveredBy_r: [
         # (2 on exception, 1 on true, 0 on false), *handle, *prepared, *geom
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSPreparedCovers_r => [
+      GEOSPreparedCovers_r: [
         # (2 on exception, 1 on true, 0 on false), *handle, *prepared, *geom
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSPreparedCrosses_r => [
+      GEOSPreparedCrosses_r: [
         # (2 on exception, 1 on true, 0 on false), *handle, *prepared, *geom
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSPreparedDisjoint_r => [
+      GEOSPreparedDisjoint_r: [
         # (2 on exception, 1 on true, 0 on false), *handle, *prepared, *geom
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSPreparedIntersects_r => [
+      GEOSPreparedIntersects_r: [
         # (2 on exception, 1 on true, 0 on false), *handle, *prepared, *geom
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSPreparedOverlaps_r => [
+      GEOSPreparedOverlaps_r: [
         # (2 on exception, 1 on true, 0 on false), *handle, *prepared, *geom
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSPreparedTouches_r => [
+      GEOSPreparedTouches_r: [
         # (2 on exception, 1 on true, 0 on false), *handle, *prepared, *geom
         :char, :pointer, :pointer, :pointer
       ],
 
-      :GEOSPreparedWithin_r => [
+      GEOSPreparedWithin_r: [
         # (2 on exception, 1 on true, 0 on false), *handle, *prepared, *geom
         :char, :pointer, :pointer, :pointer
       ],
       #### /PreparedGeometry functions ####
 
       #### WktReader functions ####
-      :GEOSWKTReader_create_r => [
+      GEOSWKTReader_create_r: [
         # *wktr, *handle
         :pointer, :pointer
       ],
 
-      :GEOSWKTReader_read_r => [
+      GEOSWKTReader_read_r: [
         # *geom, *handle, *wktr, string
         :pointer, :pointer, :pointer, :string
       ],
 
-      :GEOSWKTReader_destroy_r => [
+      GEOSWKTReader_destroy_r: [
         # void, *handle, *wktr
         :void, :pointer, :pointer
       ],
       #### /WktReader functions ###
 
       #### WktWriter functions ####
-      :GEOSWKTWriter_create_r => [
+      GEOSWKTWriter_create_r: [
         # *wktw, *handle
         :pointer, :pointer
       ],
 
-      :GEOSWKTWriter_write_r => [
+      GEOSWKTWriter_write_r: [
         # string, *handle, *wktw, *geom
         :string, :pointer, :pointer, :pointer
       ],
 
-      :GEOSWKTWriter_destroy_r => [
+      GEOSWKTWriter_destroy_r: [
         # void, *handle, *wktw
         :void, :pointer, :pointer
       ],
 
-      :GEOSWKTWriter_setTrim_r => [
+      GEOSWKTWriter_setTrim_r: [
         # void, *handle, *wktw, bool
         :void, :pointer, :pointer, :char
       ],
 
-      :GEOSWKTWriter_setRoundingPrecision_r => [
+      GEOSWKTWriter_setRoundingPrecision_r: [
         # void, *handle, *wktw, precision
         :void, :pointer, :pointer, :int
       ],
 
-      :GEOSWKTWriter_setOutputDimension_r => [
+      GEOSWKTWriter_setOutputDimension_r: [
         # void, *handle, *wktw, dimensions
         :void, :pointer, :pointer, :int
       ],
 
-      :GEOSWKTWriter_getOutputDimension_r => [
+      GEOSWKTWriter_getOutputDimension_r: [
         # dimensions, *handle, *wktw
         :int, :pointer, :pointer
       ],
 
-      :GEOSWKTWriter_setOld3D_r => [
+      GEOSWKTWriter_setOld3D_r: [
         # void, *handle, *wktw, bool
         :void, :pointer, :pointer, :int
       ],
       #### /WktWriter functions ####
 
       #### WkbReader functions ####
-      :GEOSWKBReader_create_r => [
+      GEOSWKBReader_create_r: [
         # *wkbr, *handle
         :pointer, :pointer
       ],
 
-      :GEOSWKBReader_destroy_r => [
+      GEOSWKBReader_destroy_r: [
         # void, *handle, *wkbr
         :void, :pointer, :pointer
       ],
 
-      :GEOSWKBReader_read_r => [
+      GEOSWKBReader_read_r: [
         # *geom, *handle, *wkbr, (unsigned char *) string, size_t
         :pointer, :pointer, :pointer, :pointer, :size_t
       ],
 
-      :GEOSWKBReader_readHEX_r => [
+      GEOSWKBReader_readHEX_r: [
         # *geom, *handle, *wkbr, string, size_t
         :pointer, :pointer, :pointer, :string, :size_t
       ],
       #### /WkbReader functions ####
 
       #### WkbWriter functions ####
-      :GEOSWKBWriter_create_r => [
+      GEOSWKBWriter_create_r: [
         # *wkbw, *handle
         :pointer, :pointer
       ],
 
-      :GEOSWKBWriter_destroy_r => [
+      GEOSWKBWriter_destroy_r: [
         # void, *handle, *wkbw
         :void, :pointer, :pointer
       ],
 
-      :GEOSWKBWriter_write_r => [
+      GEOSWKBWriter_write_r: [
         # (unsigned char *) string, *handle, *wkbw, *geom, *size_t
         :pointer, :pointer, :pointer, :pointer, :pointer
       ],
 
-      :GEOSWKBWriter_writeHEX_r => [
+      GEOSWKBWriter_writeHEX_r: [
         # (unsigned char *) string, *handle, *wkbw, *geom, *size_t
         :pointer, :pointer, :pointer, :pointer, :pointer
       ],
 
-      :GEOSWKBWriter_setOutputDimension_r => [
+      GEOSWKBWriter_setOutputDimension_r: [
         # void, *handle, *wkbw, dimensions
         :void, :pointer, :pointer, :int
       ],
 
-      :GEOSWKBWriter_getOutputDimension_r => [
+      GEOSWKBWriter_getOutputDimension_r: [
         # dimensions, *handle, *wkbw
         :int, :pointer, :pointer
       ],
 
-      :GEOSWKBWriter_getByteOrder_r => [
+      GEOSWKBWriter_getByteOrder_r: [
         # byte_order, *handle, *wkbw
         :byte_order, :pointer, :pointer
       ],
 
-      :GEOSWKBWriter_setByteOrder_r => [
+      GEOSWKBWriter_setByteOrder_r: [
         # void, *handle, *wkbw, byte_order
         :void, :pointer, :pointer, :byte_order
       ],
 
-      :GEOSWKBWriter_getIncludeSRID_r => [
+      GEOSWKBWriter_getIncludeSRID_r: [
         # bool, *handle, *geom
         :char, :pointer, :pointer
       ],
 
-      :GEOSWKBWriter_setIncludeSRID_r => [
+      GEOSWKBWriter_setIncludeSRID_r: [
         # void, *handle, *geom, bool
         :void, :pointer, :pointer, :char
       ],
       #### /WkbWriter functions ####
 
-
       #### Linearref functions ####
-      :GEOSProject_r => [
+      GEOSProject_r: [
         # distance, *handle, *geom_a, *geom_b
         :double, :pointer, :pointer, :pointer
       ],
 
-      :GEOSProjectNormalized_r => [
+      GEOSProjectNormalized_r: [
         # distance, *handle, *geom_a, *geom_b
         :double, :pointer, :pointer, :pointer
       ],
 
-      :GEOSInterpolate_r => [
+      GEOSInterpolate_r: [
         # *geom, *handle, *geom, distance
         :pointer, :pointer, :pointer, :double
       ],
 
-      :GEOSInterpolateNormalized_r => [
+      GEOSInterpolateNormalized_r: [
         # *geom, *handle, *geom, distance
         :pointer, :pointer, :pointer, :double
       ],
       #### /Linearref functions ####
 
       #### BufferParams functions ####
-      :GEOSBufferParams_create_r => [
+      GEOSBufferParams_create_r: [
         # GEOSBufferParams*, *handle
         :pointer, :pointer
       ],
 
-      :GEOSBufferParams_destroy_r => [
+      GEOSBufferParams_destroy_r: [
         # void, *handle, *params
         :void, :pointer, :pointer
       ],
 
-      :GEOSBufferParams_setEndCapStyle_r => [
+      GEOSBufferParams_setEndCapStyle_r: [
         # 0 on exception, *handle, *params, style
         :int, :pointer, :pointer, :buffer_cap_style
       ],
 
-      :GEOSBufferParams_setJoinStyle_r => [
+      GEOSBufferParams_setJoinStyle_r: [
         # 0 on exception, *handle, *params, style
         :int, :pointer, :pointer, :buffer_join_style
       ],
 
-      :GEOSBufferParams_setMitreLimit_r => [
+      GEOSBufferParams_setMitreLimit_r: [
         # 0 on exception, *handle, *params, mitre_limit
         :int, :pointer, :pointer, :double
       ],
 
-      :GEOSBufferParams_setQuadrantSegments_r => [
+      GEOSBufferParams_setQuadrantSegments_r: [
         # 0 on exception, *handle, *params, quad_segs
         :int, :pointer, :pointer, :int
       ],
 
-      :GEOSBufferParams_setSingleSided_r => [
+      GEOSBufferParams_setSingleSided_r: [
         # 0 on exception, *handle, *params, bool
         :int, :pointer, :pointer, :int
       ],
@@ -1046,21 +1147,21 @@ module Geos
       # -1 if reaching P takes a counter-clockwise (left) turn
       # 1 if reaching P takes a clockwise (right) turn
       # 0 if P is collinear with A-B
-      :GEOSOrientationIndex_r => [
+      GEOSOrientationIndex_r: [
         # int, *handle, Ax, Ay, Bx, By, Px, Py
         :int, :pointer, :double, :double, :double, :double, :double, :double
       ]
       #### /Algorithms ####
-    }
+    }.freeze
 
     begin
       ffi_lib(geos_library_path)
 
-      FFI_LAYOUT.each do |fun, ary|
+      FFI_LAYOUT.each do |func, ary|
         ret = ary.shift
         begin
-          self.class_eval do
-            attach_function(fun, ary, ret)
+          class_eval do
+            attach_function(func, ary, ret)
           end
         rescue FFI::NotFoundError
           # that's okay
@@ -1069,9 +1170,8 @@ module Geos
 
       # Checks to see if we actually have the GEOS library loaded.
       FFIGeos.GEOSversion
-
     rescue LoadError, NoMethodError
-      raise LoadError.new("Couldn't load the GEOS CAPI library.")
+      raise LoadError, "Couldn't load the GEOS CAPI library."
     end
   end
 
@@ -1093,13 +1193,11 @@ module Geos
       def notice_handler=(method_or_block)
         @notice_handler = method_or_block
         FFIGeos.GEOSContext_setNoticeMessageHandler_r(@ptr, @notice_handler, nil)
-        @notice_handler
       end
 
       def error_handler=(method_or_block)
         @error_handler = method_or_block
         FFIGeos.GEOSContext_setErrorMessageHandler_r(@ptr, @error_handler, nil)
-        @error_handler
       end
 
       def notice_handler(&block)
@@ -1113,11 +1211,11 @@ module Geos
       end
 
       def reset_notice_handler
-        self.notice_handler = self.method(:default_notice_handler)
+        self.notice_handler = method(:default_notice_handler)
       end
 
       def reset_error_handler
-        self.error_handler = self.method(:default_error_handler)
+        self.error_handler = method(:default_error_handler)
       end
 
     # Deprecated initialization and teardown...
@@ -1125,8 +1223,8 @@ module Geos
       def initialize
         @ptr = FFI::AutoPointer.new(
           FFIGeos.initGEOS_r(
-            @notice_handler = self.method(:default_notice_handler),
-            @error_handler = self.method(:default_error_handler)
+            @notice_handler = method(:default_notice_handler),
+            @error_handler = method(:default_error_handler)
           ),
           self.class.method(:release)
         )
@@ -1136,28 +1234,25 @@ module Geos
         FFIGeos.finishGEOS_r(ptr)
       end
 
-      def notice_handler
-        @notice_handler
-      end
+      attr_reader :notice_handler
 
-      def error_handler
-        @error_handler
-      end
+      attr_reader :error_handler
     end
 
     private
+
       def default_notice_handler(*args)
         # no-op
       end
 
       def default_error_handler(*args)
-        raise Geos::GEOSException.new(args[0] % args[1])
+        raise Geos::GEOSException, args[0] % args[1]
       end
   end
 
   class << self
     def version
-      @version ||= FFIGeos.GEOSversion
+      @version ||= FFIGeos.GEOSversion.strip
     end
 
     def jts_port
@@ -1202,7 +1297,7 @@ module Geos
       elsif Geos::Constants::SRID_COPY_POLICIES.include?(policy)
         Thread.current[:ffi_geos_srid_copy_policy] = policy
       else
-        raise ArgumentError.new("Invalid SRID policy #{policy} (must be one of #{Geos::Constants::SRID_COPY_POLICIES})")
+        raise ArgumentError, "Invalid SRID policy #{policy} (must be one of #{Geos::Constants::SRID_COPY_POLICIES})"
       end
     end
 
@@ -1216,7 +1311,7 @@ module Geos
       elsif Geos::Constants::SRID_COPY_POLICIES.include?(policy)
         @srid_copy_policy_default = policy
       else
-        raise ArgumentError.new("Invalid SRID policy #{policy} (must be one of #{Geos::Constants::SRID_COPY_POLICIES})")
+        raise ArgumentError, "Invalid SRID policy #{policy} (must be one of #{Geos::Constants::SRID_COPY_POLICIES})"
       end
     end
 
@@ -1241,11 +1336,11 @@ module Geos
       create_empty_collection
       create_empty_linear_ring
     }.each do |m|
-      self.class_eval(<<-EOF, __FILE__, __LINE__ + 1)
+      class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
         def #{m}(*args)
           Geos::Utils.#{m}(*args)
         end
-      EOF
+      RUBY
     end
   end
 
@@ -1268,38 +1363,38 @@ module Geos
       GEOS_CAPI_VERSION,
       GEOS_CAPI_VERSION_MAJOR, GEOS_CAPI_VERSION_MINOR, GEOS_CAPI_VERSION_PATCH,
       GEOS_SVN_REVISION =
-        if !(versions = Geos.version.scan(/^
-          ((\d+)\.(\d+)\.(\d+)((?:dev|rc|beta|alpha)\d*)?)
-          -CAPI-
-          ((\d+)\.(\d+)\.(\d+))
-          (?:\s+r(\d+))?
-        $/x)).empty?
-          versions = versions[0]
-          [
-            versions[0],
-            versions[1].to_i,
-            versions[2].to_i,
-            versions[3].to_i,
-            versions[4],
-            versions[5],
-            versions[6].to_i,
-            versions[7].to_i,
-            versions[8].to_i,
-            (versions[9].to_i if versions[9])
-          ]
-        else
-          [ '0.0.0', 0, 0, 0, nil, '0.0.0', 0, 0, 0 ]
-        end
+      if !(versions = Geos.version.scan(/^
+        ((\d+)\.(\d+)\.(\d+)((?:dev|rc|beta|alpha)\d*)?)
+        -CAPI-
+        ((\d+)\.(\d+)\.(\d+))
+        (?:\s+r?(\h+))?
+      $/x)).empty?
+        versions = versions[0]
+        [
+          versions[0],
+          versions[1].to_i,
+          versions[2].to_i,
+          versions[3].to_i,
+          versions[4],
+          versions[5],
+          versions[6].to_i,
+          versions[7].to_i,
+          versions[8].to_i,
+          versions[9]&.to_i
+        ]
+      else
+        ['0.0.0', 0, 0, 0, nil, '0.0.0', 0, 0, 0]
+      end
     GEOS_CAPI_FIRST_INTERFACE = GEOS_CAPI_VERSION_MAJOR.to_i
     GEOS_CAPI_LAST_INTERFACE = GEOS_CAPI_VERSION_MAJOR.to_i + GEOS_CAPI_VERSION_MINOR.to_i
   end
 
   module Constants
     BUFFER_PARAM_DEFAULTS = {
-      :quad_segs => 8,
-      :endcap => :round,
-      :join => :round,
-      :mitre_limit => 5.0
+      quad_segs: 8,
+      endcap: :round,
+      join: :round,
+      mitre_limit: 5.0
     }.freeze
 
     SRID_COPY_POLICIES = [
@@ -1317,7 +1412,7 @@ module Geos
 
   class IndexBoundsError < Error
     def initialize(*)
-      super("Index out of bounds")
+      super('Index out of bounds')
     end
   end
 
@@ -1330,6 +1425,9 @@ module Geos
   class ParseError < Error
   end
 
+  class InvalidGeometryError < Error
+  end
+
   include GeomTypes
   include VersionConstants
 end