ffi-geos 0.2.1 → 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: ceab1a4b690aced547fbaea6008072689e803a35
+  data.tar.gz: 3e0c22f99d9a9884a9d755c0dd09698b68dbe6bf
+SHA512:
+  metadata.gz: 96aa99fbd28ad9fb6bfffaa08e77b5a788107c2e608976baf4b20e7a38e711942fcedc9de9eb8795174a9f7e9af5cf1641ccc40559122ce6080d993994067ae1
+  data.tar.gz: 1307315dc60642d103c41df11c82c810c7c08f6b6d2c4b70e23aae224ea5bcf08fec0fe3ed1d816214f9bf306622b8b7fffda762402c85d7d4dddf53915d22da

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2012 J Smith <dark.panda@gmail.com>
+Copyright (c) 2013 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

@@ -9,9 +9,9 @@
 
 Ruby versions known to work:
 
-* Ruby MRI 1.8.7, 1.9.2 and 1.9.3 x86_64, OSX 10.6.5+
-* Ruby MRI 1.8.7 and 1.9.2, i386, linux
-* Ruby MRI 1.8.7, 1.9.2 and 1.9.3, x86_64, linux
+* Ruby MRI 1.8.7, 1.9.2, 1.9.3, 2.0.0 x86_64, OSX 10.6.5+
+* Ruby MRI 1.8.7, 1.9.2, 1.9.3, 2.0.0 i386, linux
+* Ruby MRI 1.8.7, 1.9.2, 1.9.3, 2.0.0 x86_64, linux
 * JRuby 1.6, x86_64 OSX 10.6.5+
 
 === JRuby Notes
@@ -58,6 +58,10 @@ Ruby bindings along with the following enhancements and additions:
 * Geos::PreparedGeometry class and Geos::Geometry#to_prepared method to
   allow for prepared geometries and more efficient relationship testing.
 
+* Geos::Interrupt module that allows you to interrupt certain calls to the
+  GEOS library and perform other work or cancel GEOS calls outright. The
+  interruption API was added in GEOS 3.4.0.
+
 == New Methods and Additions (not exhaustive)
 
 * SRIDs can be copied on many operations. GEOS doesn't usually copy SRIDs
@@ -69,88 +73,100 @@ Ruby bindings along with the following enhancements and additions:
 
 === Geos
 
-* Geos.create_multi_point
-
-* Geos.create_multi_line_string
-
-* Geos.create_multi_polygon
-
-* Geos.create_geometry_collection
-
-* Geos.create_collection
-
-* Geos.create_empty_point
-
-* Geos.create_empty_polygon
-
-* Geos.create_empty_line_string
-
-* Geos.create_empty_multi_point
-
-* Geos.create_empty_multi_line_string
+* Many new Geos.create_* methods, such as Geos.create_linear_ring, etc.
 
-* Geos.create_empty_multi_polygon
-
-* Geos.create_empty_geometry_collection
+* Geos.srid_copy_policy, srid_copy_policy=, srid_copy_policy_default and
+  srid_copy_policy_default=.
 
 === Geos::Geometry
 
-* Geos::Geometry#num_coordinates
-
-* Geos::Geometry#union_cascaded. Geos::Geometry#union can also be called
+* Geos::almost_equals?
+* Geos::coord_seq
+* Geos::covered_by?
+* Geos::covers?
+* Geos::delaunay_triangulation
+* Geos::end_point
+* Geos::eql_almost?
+* Geos::equals?
+* Geos::equals_almost?
+* Geos::equals_exact?
+* Geos::exactly_equals?
+* Geos::extract_unique_points - Geos::Geometry#unique_points
+* Geos::hausdorff_distance
+* Geos::interpolate
+* Geos::interpolate_normalized
+* Geos::nearest_points
+* Geos::node
+* Geos::normalize!
+* Geos::num_coordinates
+* Geos::polygonize
+* Geos::polygonize_cut_edges
+* Geos::polygonize_full
+* Geos::project
+* Geos::project_normalized
+* Geos::relate_boundary_node_rule
+* Geos::representative_point
+* Geos::shared_paths
+* Geos::snap
+* Geos::snap_to
+* Geos::start_point
+* Geos::symmetric_difference
+* Geos::to_prepared
+* Geos::unary_union
+* Geos::union_cascaded - Geos::Geometry#union can also be called
   without a geometry argument to produce the same effect.
-
-* Geos::Geometry#extract_unique_points (aliased to Geos::Geometry#unique_points)
-
-* Geos::Geometry#valid_reason
-
-* Geos::Geometry#valid_detail
-
-* Geos::Geometry#project
-
-* Geos::Geometry#project_normalized
-
-* Geos::Geometry#interpolate
-
-* Geos::Geometry#interpolate_normalized
-
-* Geos::Geometry#start_point
-
-* Geos::Geometry#end_point
-
-* Geos::Geometry#hausdorff_distance
-
-* Geos::Geometry#snap
-
-* Geos::Geometry#shared_paths
-
-* Geos::Geometry#polygonize_full
-
-* Geos::Geometry#polygonize
-
-* Geos::Geometry#polygonize_cut_edges
-
-* Geos::Geometry#to_prepared
+* Geos::unique_points - Geos::Geometry#extract_unique_points
+* Geos::valid_detail
+* Geos::valid_reason
 
 === Geos::LineString and Geos::LinearRing
 
+* Geos::LineString#[]
+* Geos::LineString#closed?
+* Geos::LineString#each
 * Geos::LineString#num_points
-
+* Geos::LineString#offset_curve
 * Geos::LineString#point_n
-
-* Geos::LineString#closed?
+* Geos::LineString#slice
+* Geos::LinearRing#to_line_string
+* Geos::LinearRing#to_polygon
 
 === Geos::WktWriter
 
+* Geos::WktWriter#old_3d
+* Geos::WktWriter#old_3d=
+* Geos::WktWriter#output_dimensions
+* Geos::WktWriter#output_dimensions=
+* Geos::WktWriter#rounding_precision
+* Geos::WktWriter#rounding_precision=
+* Geos::WktWriter#trim
 * Geos::WktWriter#trim=
 
-* Geos::WktWriter#rounding_precision=
+=== Geos::CoordinateSequence
 
-* Geos::WktWriter#old_3d=
+* Geos::CoordinateSequence#has_z?
+* Geos::CoordinateSequence#to_line_string
+* Geos::CoordinateSequence#to_linear_ring
+* Geos::CoordinateSequence#to_point
+* Geos::CoordinateSequence#to_polygon
+
+=== Geos::Polygon
+
+* Geos::Polygon#interior_ring
+* Geos::Polygon#interior_rings
 
 === Geos::Utils
 
 * Geos::Utils.orientation_index
+* Geos::Utils.relate_match
+
+=== Geos::Interrupt
+
+* Geos::Interrupt.available?
+* Geos::Interrupt.register
+* Geos::Interrupt.request
+* Geos::Interrupt.cancel
+* Geos::Interrupt.clear
 
 == Thanks
 

data/lib/ffi-geos.rb

@@ -45,6 +45,8 @@ module Geos
     File.join(GEOS_BASE, 'tools')
   autoload :Utils,
     File.join(GEOS_BASE, 'utils')
+  autoload :Interrupt,
+    File.join(GEOS_BASE, 'interrupt')
 
   module FFIGeos
     def self.search_paths
@@ -151,6 +153,19 @@ module Geos
         :void, :pointer
       ],
 
+      :GEOS_interruptRegisterCallback => [
+        :pointer,
+        callback([], :void)
+      ],
+
+      :GEOS_interruptRequest => [
+        :void
+      ],
+
+      :GEOS_interruptCancel => [
+        :void
+      ],
+
       :GEOSversion => [
         :string
       ],
@@ -399,6 +414,11 @@ module Geos
         :pointer, :pointer, :pointer
       ],
 
+      :GEOSNode_r => [
+        # *geom, *handle, *geom
+        :pointer, :pointer, :pointer
+      ],
+
       # Deprecated in GEOS 3.3.0. Use GEOSUnaryUnion_r instead.
       :GEOSUnionCascaded_r => [
         # *geom, *handle, *geom
@@ -450,6 +470,11 @@ module Geos
         :pointer, :pointer, :pointer, :pointer, :double
       ],
 
+      :GEOSDelaunayTriangulation_r => [
+        # *geom, *handle, *geom, tolerance, only_edges
+        :pointer, :pointer, :pointer, :double, :int
+      ],
+
       :GEOSRelate_r => [
         # string, *handle, *geom_a, *geom_b
         :string, :pointer, :pointer, :pointer
@@ -590,6 +615,11 @@ module Geos
         :int, :pointer, :pointer, :pointer, :double, :pointer
       ],
 
+      :GEOSNearestPoints_r => [
+        # (NULL on exception, pointer to CoordinateSequence otherwise), *handle, *geom, *geom
+        :pointer, :pointer, :pointer, :pointer
+      ],
+
       :GEOSGetGeometryN_r => [
         # *geom, *handle, *geom, n
         :pointer, :pointer, :pointer, :int

data/lib/ffi-geos/coordinate_sequence.rb

@@ -44,7 +44,7 @@ module Geos
     attr_reader :ptr, :x, :y, :z
 
     # :call-seq:
-    #   new(ptr, auto_free = true)
+    #   new(ptr, auto_free = true, parent = nil)
     #   new(size = 0, dimensions = 0)
     #   new(options)
     #   new(points)
@@ -58,8 +58,8 @@ module Geos
     def initialize(*args)
       points = nil # forward declaration we can use later
 
-      ptr, auto_free = if args.first.is_a?(FFI::Pointer)
-        [ args.first, args[1] ]
+      ptr, auto_free, parent = if args.first.is_a?(FFI::Pointer)
+        args.first(3)
       else
         size, dimensions = if args.first.is_a?(Array)
           points = if args.first.first.is_a?(Array)
@@ -100,6 +100,7 @@ module Geos
       )
 
       @ptr.autorelease = auto_free
+      @parent = parent if parent
 
       @x = CoordinateAccessor.new(self, 0)
       @y = CoordinateAccessor.new(self, 1)

data/lib/ffi-geos/geometry.rb

@@ -76,7 +76,7 @@ module Geos
     end
 
     def coord_seq
-      CoordinateSequence.new(FFIGeos.GEOSGeom_getCoordSeq_r(Geos.current_handle, self.ptr), false)
+      CoordinateSequence.new(FFIGeos.GEOSGeom_getCoordSeq_r(Geos.current_handle, self.ptr), false, self)
     end
 
     def intersection(geom)
@@ -189,6 +189,13 @@ module Geos
       end
     end
 
+    if FFIGeos.respond_to?(:GEOSNode_r)
+      # Available in GEOS 3.3.4+
+      def node
+        cast_geometry_ptr(FFIGeos.GEOSNode_r(Geos.current_handle, self.ptr))
+      end
+    end
+
     def point_on_surface
       cast_geometry_ptr(FFIGeos.GEOSPointOnSurface_r(Geos.current_handle, self.ptr), :srid_copy => self.srid)
     end
@@ -473,6 +480,18 @@ module Geos
       double_ptr.read_double
     end
 
+    if FFIGeos.respond_to?(:GEOSNearestPoints_r)
+      # Available in GEOS 3.4+.
+      def nearest_points(geom)
+        check_geometry(geom)
+        ptr = FFIGeos.GEOSNearestPoints_r(Geos.current_handle, self.ptr, geom.ptr)
+
+        if !ptr.null?
+          CoordinateSequence.new(ptr)
+        end
+      end
+    end
+
     def snap(geom, tolerance)
       check_geometry(geom)
       cast_geometry_ptr(FFIGeos.GEOSSnap_r(Geos.current_handle, self.ptr, geom.ptr, tolerance), {
@@ -533,6 +552,12 @@ module Geos
       cast_geometry_ptr(FFIGeos.GEOSPolygonizer_getCutEdges_r(Geos.current_handle, ary, 1), :srid_copy => self.srid).to_a
     end
 
+    if FFIGeos.respond_to?(:GEOSDelaunayTriangulation_r)
+      def delaunay_triangulation(tolerance, options = {})
+        cast_geometry_ptr(FFIGeos.GEOSDelaunayTriangulation_r(Geos.current_handle, self.ptr, tolerance, options[:only_edges] ? 1 : 0))
+      end
+    end
+
     def to_prepared
       Geos::PreparedGeometry.new(self)
     end

data/lib/ffi-geos/interrupt.rb

@@ -0,0 +1,73 @@
+
+module Geos
+  module Interrupt
+    class << self
+      if FFIGeos.respond_to?(:GEOS_interruptRegisterCallback)
+        # Check for the availability of the GEOS interruption API. The
+        # interruption API was added in GEOS 3.4.0.
+        def available?
+          true
+        end
+
+        # Registers an interrupt method or block that may be called during
+        # certain operations such as Geos::Geometry#buffer. During these
+        # blocks you can interrupt the current operation using
+        # Geos.request_interrupt and cancel that interrupt request using
+        # Geos.clear_interrupt.
+        #
+        # The return value for Geos.register_interrupt is a reference to the
+        # previously registered callback, allowing you to chain interrupt
+        # calls together by calling #call on the previously registered callback.
+        #
+        # HUGE NOTE CONCERNING INTERRUPTS: be careful when using interrupt
+        # blocks and how they reference other ruby objects. The ruby garbage
+        # collector may not play nicely with GEOS and objects may get cleaned
+        # up in unexpected ways while interrupts are firing.
+        def register(method_or_block = nil, &block)
+          if method_or_block.nil? && !block_given?
+            raise ArgumentError.new("Expected either a method or a block for Geos.register_interrupt")
+          elsif !method_or_block.nil? && block_given?
+            raise ArgumentError.new("Cannot use both a method and a block for Geos.register_interrupt")
+          else
+            retval = @current_interrupt_callback
+
+            @current_interrupt_callback = if method_or_block
+              FFIGeos.GEOS_interruptRegisterCallback(method_or_block)
+              method_or_block
+            elsif block_given?
+              FFIGeos.GEOS_interruptRegisterCallback(&block)
+              block
+            end
+
+            retval
+          end
+        end
+
+        # Interrupt the current operation. This method should generally be
+        # called from within a callback registered with Geos.register_interrupt
+        # but can be called at any time to interrupt the next interruptable
+        # operation.
+        def request
+          FFIGeos.GEOS_interruptRequest
+        end
+
+        # Cancel a request to interrupt the current operation. This method
+        # should be called from within a callback registered with
+        # Geos.register_interrupt but can be called at any time all the same.
+        def cancel
+          FFIGeos.GEOS_interruptCancel
+        end
+
+        def clear
+          FFIGeos.GEOS_interruptRegisterCallback(nil)
+          @current_interrupt_callback = nil
+        end
+      else
+        def available?
+          false
+        end
+      end
+    end
+  end
+end
+

data/lib/ffi-geos/version.rb

@@ -1,6 +1,6 @@
 # encoding: UTF-8
 
 module Geos
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end
 

data/lib/ffi-geos/wkb_writer.rb

@@ -24,13 +24,6 @@ module Geos
       FFIGeos.GEOSWKBWriter_destroy_r(Geos.current_handle, ptr)
     end
 
-    def set_options(options = {}) #:nodoc:
-      [ :include_srid ].each do |k|
-        self.send("#{k}=", options[k]) if options.has_key?(k)
-      end
-    end
-    private :set_options
-
     # Options can be set temporarily for individual writes using an options
     # Hash. The only option currently available is :include_srid.
     def write(geom, options = nil)
@@ -92,5 +85,12 @@ module Geos
       check_enum_value(Geos::ByteOrders, val)
       FFIGeos.GEOSWKBWriter_setByteOrder_r(Geos.current_handle, self.ptr, val)
     end
+
+    private
+      def set_options(options) #:nodoc:
+        [ :include_srid ].each do |k|
+          self.send("#{k}=", options[k]) if options.has_key?(k)
+        end
+      end
   end
 end

data/test/geometry_tests.rb

@@ -481,6 +481,16 @@ class GeometryTests < MiniTest::Unit::TestCase
     )
   end
 
+  def test_node
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:node)
+
+    self_tester(
+      :node,
+      'LINESTRING(0 0, 10 0, 5 -5, 5 5)',
+      'MULTILINESTRING ((0 0, 5 0), (5 0, 10 0, 5 -5, 5 0), (5 0, 5 5))'
+    )
+  end
+
   def test_union_without_arguments
     self_tester(
       :union,
@@ -1299,6 +1309,35 @@ class GeometryTests < MiniTest::Unit::TestCase
     tester[9.0, geom_a, 'LINESTRING (3 0 , 10 0)']
   end
 
+  def test_nearest_points
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:nearest_points)
+
+    tester = lambda { |expected, g1, g2|
+      geom_1 = read(g1)
+      geom_2 = read(g2)
+
+      cs = geom_1.nearest_points(geom_2)
+
+      result = if cs
+        cs.to_s
+      end
+
+      assert_equal(expected, result)
+    }
+
+    tester[
+      nil,
+      'POINT EMPTY',
+      'POINT EMPTY'
+    ]
+
+    tester[
+      '5.0 5.0 NaN, 8.0 8.0 NaN',
+      'POLYGON((1 1, 1 5, 5 5, 5 1, 1 1))',
+      'POLYGON((8 8, 9 9, 9 10, 8 8))'
+    ]
+  end
+
   def test_snap
     skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:snap)
 
@@ -1642,4 +1681,52 @@ class GeometryTests < MiniTest::Unit::TestCase
   def test_to_s
     assert_match(/^\#<Geos::Point: .+>$/, read('POINT(0 0)').to_s)
   end
+
+  def test_delaunay_triangulation
+    skip unless ENV['FORCE_TESTS'] || Geos::Geometry.method_defined?(:delaunay_triangulation)
+
+    tester = lambda { |expected, geom, *args|
+      geom = read(geom)
+      geom_tri = geom.delaunay_triangulation(*args)
+      geom_tri.normalize!
+
+      assert_equal(expected, write(geom_tri))
+    }
+
+    writer.trim = true
+
+    # empty polygon
+    tester['GEOMETRYCOLLECTION EMPTY', 'POLYGON EMPTY', 0]
+    tester['MULTILINESTRING EMPTY', 'POLYGON EMPTY', 0, { :only_edges => true }]
+
+    # single point
+    tester['GEOMETRYCOLLECTION EMPTY', 'POINT (0 0)', 0]
+    tester['MULTILINESTRING EMPTY', 'POINT (0 0)', 0, { :only_edges => true }]
+
+    # three collinear points
+    tester['GEOMETRYCOLLECTION EMPTY', 'MULTIPOINT(0 0, 5 0, 10 0)', 0]
+    tester['MULTILINESTRING ((5 0, 10 0), (0 0, 5 0))', 'MULTIPOINT(0 0, 5 0, 10 0)', 0, { :only_edges => true }]
+
+    # three points
+    tester['GEOMETRYCOLLECTION (POLYGON ((0 0, 10 10, 5 0, 0 0)))', 'MULTIPOINT(0 0, 5 0, 10 10)', 0]
+    tester['MULTILINESTRING ((5 0, 10 10), (0 0, 10 10), (0 0, 5 0))', 'MULTIPOINT(0 0, 5 0, 10 10)', 0, { :only_edges => true }]
+
+    # polygon with a hole
+    tester[
+      'GEOMETRYCOLLECTION (POLYGON ((8 2, 10 10, 8.5 1, 8 2)), POLYGON ((7 8, 10 10, 8 2, 7 8)), POLYGON ((3 8, 10 10, 7 8, 3 8)), POLYGON ((2 2, 8 2, 8.5 1, 2 2)), POLYGON ((2 2, 7 8, 8 2, 2 2)), POLYGON ((2 2, 3 8, 7 8, 2 2)), POLYGON ((0.5 9, 10 10, 3 8, 0.5 9)), POLYGON ((0.5 9, 3 8, 2 2, 0.5 9)), POLYGON ((0 0, 2 2, 8.5 1, 0 0)), POLYGON ((0 0, 0.5 9, 2 2, 0 0)))',
+      'POLYGON((0 0, 8.5 1, 10 10, 0.5 9, 0 0),(2 2, 3 8, 7 8, 8 2, 2 2)))',
+      0
+    ]
+
+    tester[
+      'MULTILINESTRING ((8.5 1, 10 10), (8 2, 10 10), (8 2, 8.5 1), (7 8, 10 10), (7 8, 8 2), (3 8, 10 10), (3 8, 7 8), (2 2, 8.5 1), (2 2, 8 2), (2 2, 7 8), (2 2, 3 8), (0.5 9, 10 10), (0.5 9, 3 8), (0.5 9, 2 2), (0 0, 8.5 1), (0 0, 2 2), (0 0, 0.5 9))',
+      'POLYGON((0 0, 8.5 1, 10 10, 0.5 9, 0 0),(2 2, 3 8, 7 8, 8 2, 2 2)))',
+      0, {
+        :only_edges => true
+      }
+    ]
+
+    # four points with a tolerance making one collapse
+    tester['MULTILINESTRING ((10 0, 10 10), (0 0, 10 10), (0 0, 10 0))', 'MULTIPOINT(0 0, 10 0, 10 10, 11 10)', 2.0, { :only_edges => true }]
+  end
 end

data/test/interrupt_tests.rb

@@ -0,0 +1,192 @@
+# encoding: UTF-8
+
+$: << File.dirname(__FILE__)
+require 'test_helper'
+
+class InterruptTests < MiniTest::Unit::TestCase
+  include TestHelper
+
+  def interrupt_method
+    interrupt_called
+    Geos::Interrupt.request
+  end
+
+  def interrupt_tester
+    yield
+  ensure
+    Geos::Interrupt.clear
+  end
+
+  def interrupt_called
+    @interrupt_calls += 1
+  end
+
+  def setup
+    super
+    @interrupt_calls = 0
+  end
+
+  def assert_interrupt_called(times = 0)
+    assert(@interrupt_calls > times, "Expected @interrupt_calls to be > #{times}")
+  end
+
+  def test_interrupt_with_method
+    skip unless ENV['FORCE_TESTS'] || Geos::Interrupt.available?
+
+    interrupt_tester do
+      geom = read('LINESTRING(0 0, 1 0)')
+
+      Geos::Interrupt.register(self.method(:interrupt_method))
+
+      begin
+        buffer = geom.buffer(1, 8)
+      rescue => e
+        assert_match(/^InterruptedException/, e.message)
+        assert_nil(buffer)
+        assert_interrupt_called
+      end
+    end
+  end
+
+  def test_interrupt_with_block
+    skip unless ENV['FORCE_TESTS'] || Geos::Interrupt.available?
+
+    interrupt_tester do
+      geom = read('LINESTRING(0 0, 1 0)')
+
+      Geos::Interrupt.register do
+        interrupt_called
+        Geos::Interrupt.request
+      end
+
+      begin
+        buffer = geom.buffer(1, 8)
+      rescue => e
+        assert_match(/^InterruptedException/, e.message)
+        assert_nil(buffer)
+        assert_interrupt_called
+      end
+    end
+  end
+
+  def test_interrupt_with_proc
+    skip unless ENV['FORCE_TESTS'] || Geos::Interrupt.available?
+
+    interrupt_tester do
+      geom = read('LINESTRING(0 0, 1 0)')
+
+      prc = proc {
+        interrupt_called
+        Geos::Interrupt.request
+      }
+
+      Geos::Interrupt.register(prc)
+
+      begin
+        buffer = geom.buffer(1, 8)
+      rescue => e
+        assert_match(/^InterruptedException/, e.message)
+        assert_nil(buffer)
+        assert_interrupt_called
+      end
+    end
+  end
+
+  def test_chain_interrupts
+    skip unless ENV['FORCE_TESTS'] || Geos::Interrupt.available?
+
+    interrupt_tester do
+      geom = read('LINESTRING(0 0, 1 0)')
+      prev = nil
+      called = []
+
+      prc_0 = proc {
+        interrupt_called
+        called << :prc_0
+        Geos::Interrupt.request
+      }
+
+      prc_1 = proc {
+        interrupt_called
+        called << :prc_1
+        prev.call if prev
+      }
+
+      Geos::Interrupt.register(prc_0)
+      prev = Geos::Interrupt.register(prc_1)
+
+      begin
+        buffer = geom.buffer(1, 8)
+      rescue => e
+        assert_match(/^InterruptedException/, e.message)
+        assert_nil(buffer)
+        assert_interrupt_called(1)
+        assert_equal([ :prc_1, :prc_0 ], called)
+      end
+    end
+  end
+
+  def test_cancel_interrupt
+    skip unless ENV['FORCE_TESTS'] || Geos::Interrupt.available?
+
+    interrupt_tester do
+      geom = read('LINESTRING(0 0, 1 0)')
+
+      Geos::Interrupt.register do
+        Geos::Interrupt.request
+        interrupt_called
+        Geos::Interrupt.cancel
+      end
+
+      buffer = geom.buffer(1, 8)
+
+      assert_kind_of(Geos::Polygon, buffer)
+      assert_interrupt_called(1)
+    end
+  end
+
+  def test_request_interrupt_without_a_callback
+    skip unless ENV['FORCE_TESTS'] || Geos::Interrupt.available?
+
+    geom = read('LINESTRING(0 0, 1 0)')
+    Geos::Interrupt.request
+
+    begin
+      buffer = geom.buffer(1, 8)
+    rescue => e
+      assert_match(/^InterruptedException/, e.message)
+      assert_nil(buffer)
+    end
+  end
+
+  def test_cancel_interrupt_without_a_callback
+    skip unless ENV['FORCE_TESTS'] || Geos::Interrupt.available?
+
+    geom = read('LINESTRING(0 0, 1 0)')
+    Geos::Interrupt.request
+    Geos::Interrupt.cancel
+
+    buffer = geom.buffer(1, 8)
+
+    assert_kind_of(Geos::Polygon, buffer)
+  end
+
+  def test_interrupt_with_method_and_block
+    skip unless ENV['FORCE_TESTS'] || Geos::Interrupt.available?
+
+    assert_raises(ArgumentError) do
+      Geos::Interrupt.register(self.method(:interrupt_method)) do
+        # no-op
+      end
+    end
+  end
+
+  def test_interrupt_without_method_or_block
+    skip unless ENV['FORCE_TESTS'] || Geos::Interrupt.available?
+
+    assert_raises(ArgumentError) do
+      Geos::Interrupt.register
+    end
+  end
+end
+

data/test/misc_tests.rb

@@ -85,6 +85,15 @@ class MiscTests < MiniTest::Unit::TestCase
     assert_equal(collection_a[0], collection_b[0])
   end
 
+  def test_segfault_on_coord_seq_parents
+    geom = read('LINESTRING(0 0, 1 0)')
+    cs = geom.envelope.exterior_ring.coord_seq
+
+    GC.start
+
+    assert_equal('0.0 0.0, 1.0 0.0, 1.0 0.0, 0.0 0.0, 0.0 0.0', cs.to_s)
+  end
+
   def test_cant_clone_buffer_params
     assert_raises(NoMethodError) do
       Geos::BufferParams.new.clone

data/test/test_helper.rb

@@ -7,6 +7,7 @@ if RUBY_VERSION >= '1.9'
   SimpleCov.merge_timeout(3600)
   SimpleCov.start do
     add_filter '/test/'
+    add_filter '/.bundle/'
   end
 end
 

metadata

@@ -1,30 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: ffi-geos
 version: !ruby/object:Gem::Version
-  prerelease: 
-  version: 0.2.1
+  version: 0.3.0
 platform: ruby
 authors:
 - J Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-02 00:00:00.000000000 Z
+date: 2013-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
-  type: :runtime
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.0.0
+  type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: 1.0.0
 description: An ffi wrapper for GEOS, a C++ port of the Java Topology Suite (JTS).
@@ -46,6 +43,7 @@ files:
 - lib/ffi-geos/coordinate_sequence.rb
 - lib/ffi-geos/geometry.rb
 - lib/ffi-geos/geometry_collection.rb
+- lib/ffi-geos/interrupt.rb
 - lib/ffi-geos/line_string.rb
 - lib/ffi-geos/linear_ring.rb
 - lib/ffi-geos/multi_line_string.rb
@@ -65,6 +63,7 @@ files:
 - test/coordinate_sequence_tests.rb
 - test/geometry_collection_tests.rb
 - test/geometry_tests.rb
+- test/interrupt_tests.rb
 - test/line_string_tests.rb
 - test/linear_ring_tests.rb
 - test/misc_tests.rb
@@ -81,32 +80,32 @@ files:
 - test/wkt_writer_tests.rb
 homepage: http://github.com/dark-panda/ffi-geos
 licenses: []
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.23
+rubygems_version: 2.0.3
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: An ffi wrapper for GEOS, a C++ port of the Java Topology Suite (JTS).
 test_files:
 - test/coordinate_sequence_tests.rb
 - test/geometry_collection_tests.rb
 - test/geometry_tests.rb
+- test/interrupt_tests.rb
 - test/line_string_tests.rb
 - test/linear_ring_tests.rb
 - test/misc_tests.rb