ffi-geos 0.0.1 → 0.0.2

data/README.rdoc

@@ -12,12 +12,11 @@ Ruby versions known to work:
 * Ruby MRI 1.8.7 and 1.9.2, x86_64, OSX 10.6.5+
 * Ruby MRI 1.8.7 and 1.9.2, i386, linux
 * Ruby MRI 1.8.7, x86_64, linux
+* JRuby 1.6.3, x86_64 OSX 10.6.5+
 
-Note that versions of JRuby prior to the as-of-yet (25 June 2011) unreleased
-version 1.6.3 have problems in their ffi implementation when dealing with
-AutoPointers that can lead to segfaults during garbage collection. Upcoming
-versions of JRuby should have the problem licked. For details, check out
-http://jira.codehaus.org/browse/JRUBY-5813.
+Note that versions of JRuby prior to version 1.6.3 have problems in their ffi
+implementation when dealing with AutoPointers that can lead to segfaults during
+garbage collection.
 
 == Features
 

data/VERSION

@@ -1 +1 @@
-0.0.1
+0.0.2

data/ffi-geos.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{ffi-geos}
-  s.version = "0.0.1"
+  s.version = "0.0.2"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["J Smith"]
-  s.date = %q{2011-06-25}
+  s.date = %q{2011-07-22}
   s.description = %q{An ffi wrapper for GEOS, a C++ port of the Java Topology Suite (JTS).}
   s.email = %q{dark.panda@gmail.com}
   s.extra_rdoc_files = [
@@ -56,7 +56,7 @@ Gem::Specification.new do |s|
   ]
   s.homepage = %q{http://github.com/dark-panda/ffi-geos}
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.7.2}
+  s.rubygems_version = %q{1.6.2}
   s.summary = %q{An ffi wrapper for GEOS, a C++ port of the Java Topology Suite (JTS).}
 
   if s.respond_to? :specification_version then

data/lib/ffi-geos.rb

@@ -1026,10 +1026,10 @@ module Geos
     VERSION = File.read(File.join(GEOS_BASE, %w{ .. .. VERSION })).strip
     GEOS_JTS_PORT = Geos.jts_port
     GEOS_VERSION,
-      GEOS_VERSION_MAJOR, GEOS_VERSION_MINOR, GEOS_VERISON_PATCH, GEOS_VERSION_PRERELEASE,
+      GEOS_VERSION_MAJOR, GEOS_VERSION_MINOR, GEOS_VERSION_PATCH, GEOS_VERSION_PRERELEASE,
       GEOS_CAPI_VERSION,
       GEOS_CAPI_VERSION_MAJOR, GEOS_CAPI_VERSION_MINOR, GEOS_CAPI_VERSION_PATCH =
-        if !(versions = Geos.version.scan(/^((\d+)\.(\d+)\.(\d+)((?:rc|beta|alpha)\d+)?)-CAPI-((\d+)\.(\d+)\.(\d+))$/)).empty?
+        if !(versions = Geos.version.scan(/^((\d+)\.(\d+)\.(\d+)((?:dev|rc|beta|alpha)\d*)?)-CAPI-((\d+)\.(\d+)\.(\d+))$/)).empty?
           versions = versions[0]
           [
             versions[0],

data/lib/ffi-geos/coordinate_sequence.rb

@@ -3,23 +3,53 @@ module Geos
 
   # A CoordinateSequence is a list of coordinates in a Geometry.
   class CoordinateSequence
+    class ParseError < ArgumentError
+    end
+
     include Enumerable
 
     attr_reader :ptr
 
     # :call-seq:
     #   new(ptr, auto_free = true)
-    #   new(size, dims = 0)
+    #   new(size = 0, dims = 0)
+    #   new(points)
     #
     # The ptr version of the initializer is for internal use.
+    #
+    # new(points) will try to glean the size and dimensions of your
+    # CoordinateSequence from an Array of points. The Array should contain
+    # uniform-sized Arrays which represent the [ x, y, z ] values of your
+    # coordinates.
     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] ]
       else
-        size, dims = if !args.length.between?(1, 2)
-          raise ArgumentError.new("wrong number of arguments (#{args.length} for 1-2)")
+        size, dims = if args.first.is_a?(Array)
+          points = if args.first.first.is_a?(Array)
+            args.first
+          else
+            args
+          end
+          lengths = points.collect(&:length).uniq
+
+          if lengths.empty?
+            [ 0, 0 ]
+          elsif lengths.length != 1
+            raise ParseError.new("Different sized points found in Array")
+          elsif !lengths.first.between?(1, 3)
+            raise ParseError.new("Expected points to contain 1-3 elements")
+          else
+            [ points.length, points.first.length ]
+          end
         else
-          [ args[0], args[1] || 0]
+          if !args.length.between?(0, 2)
+            raise ArgumentError.new("wrong number of arguments (#{args.length} for 0-2)")
+          else
+            [ args[0] || 0, args[1] || 0 ]
+          end
         end
 
         [ FFIGeos.GEOSCoordSeq_create_r(Geos.current_handle, size, dims), true ]
@@ -33,6 +63,14 @@ module Geos
       if !auto_free
         @ptr.autorelease = false
       end
+
+      if points
+        points.each_with_index do |point, idx|
+          point.each_with_index do |val, dim|
+            self.set_ordinate(idx, dim, val)
+          end
+        end
+      end
     end
 
     def initialize_copy(source)
@@ -122,6 +160,18 @@ module Geos
       }.read_int
     end
 
+    def to_linear_ring
+      Geos.create_linear_ring(self)
+    end
+
+    def to_line_string
+      Geos.create_line_string(self)
+    end
+
+    def to_polygon
+      Geos.create_polygon(self)
+    end
+
     protected
 
     def check_bounds(idx) #:nodoc:

data/lib/ffi-geos/geometry_collection.rb

@@ -5,10 +5,16 @@ module Geos
 
     # Yields each Geometry in the GeometryCollection.
     def each
-      self.num_geometries.times do |n|
-        yield self.get_geometry_n(n)
+      if block_given?
+        self.num_geometries.times do |n|
+          yield self.get_geometry_n(n)
+        end
+        self
+      else
+        self.num_geometries.times.collect { |n|
+          self.get_geometry_n(n)
+        }.to_enum
       end
-      nil
     end
 
     def get_geometry_n(n)

data/lib/ffi-geos/line_string.rb

@@ -4,10 +4,16 @@ module Geos
     include Enumerable
 
     def each
-      self.num_points.times do |n|
-        yield self.point_n(n)
+      if block_given?
+        self.num_points.times do |n|
+          yield self.point_n(n)
+        end
+        self
+      else
+        self.num_points.times.collect { |n|
+          self.point_n(n)
+        }.to_enum
       end
-      nil
     end
 
     if FFIGeos.respond_to?(:GEOSGeomGetNumPoints_r)

data/lib/ffi-geos/strtree.rb

@@ -8,7 +8,33 @@ module Geos
 
     undef :clone, :dup
 
-    def initialize(capacity)
+    # :call-seq:
+    #   new(capacity)
+    #   new(geoms_and_objects)
+    #
+    def initialize(*args)
+      geoms_and_objects = nil # forward declaration
+
+      capacity = if args.length == 1 && args.first.is_a?(Fixnum)
+        args.first
+      else
+        geoms_and_objects = if args.first.first.is_a?(Array)
+          args.first
+        else
+          args
+        end
+
+        geoms_and_objects.each do |geom, obj|
+          check_geometry(geom)
+        end
+
+        geoms_and_objects.length
+      end
+
+      if capacity <= 0
+        raise ArgumentError.new("STRtree capacity must be greater than 0")
+      end
+
       ptr = FFIGeos.GEOSSTRtree_create_r(Geos.current_handle, capacity)
 
       @ptr = FFI::AutoPointer.new(
@@ -17,9 +43,16 @@ module Geos
       )
 
       @storage = {}
-      @storage_pointers = {}
+      @ptrs = {}
+
       @storage_key = 0
       @built = false
+
+      if geoms_and_objects
+        geoms_and_objects.each do |geom, obj|
+          self.insert(geom, obj)
+        end
+      end
     end
 
     def self.release(ptr) #:nodoc:
@@ -36,17 +69,21 @@ module Geos
     private :next_key
 
     def insert(geom, item)
-      check_geometry(geom)
-
       if self.built?
         raise RuntimeError.new("STRtree has already been built")
       else
+        check_geometry(geom)
+
         key = next_key
         key_ptr = FFI::MemoryPointer.new(:pointer)
         key_ptr.write_int(key)
 
-        @storage[key] = item
-        @storage_pointers[key] = key_ptr
+        @storage[key] = {
+          :item => item,
+          :geometry => geom
+        }
+        @ptrs[key] = key_ptr
+
         FFIGeos.GEOSSTRtree_insert_r(Geos.current_handle, self.ptr, geom.ptr, key_ptr)
       end
     end
@@ -54,41 +91,36 @@ module Geos
     def remove(geom, item)
       check_geometry(geom)
 
-      key = if @storage.respond_to?(:key)
-        @storage.key(item)
-      else
-        @storage.index(item)
+      key = if storage = @storage.detect { |k, v| v[:item] == item }
+        storage[0]
       end
 
       if key
-        key_ptr = @storage_pointers[key]
+        key_ptr = @ptrs[key]
         result = FFIGeos.GEOSSTRtree_remove_r(Geos.current_handle, self.ptr, geom.ptr, key_ptr)
         @built = true
 
         if result == 1
-          @storage[key] = nil
-          @storage_pointers[key] = nil
+          @storage.delete(key)
         end
       end
     end
 
-    def query(geom)
+    def query_all(geom)
       check_geometry(geom)
 
       @built = true
-      retval = nil
+      retval = []
 
-      callback = if block_given?
-        proc { |*args|
-          key = args.first.read_int
-          yield(@storage[key])
-        }
-      else
-        retval = []
-        proc { |*args|
-          retval << @storage[args.first.read_int]
-        }
-      end
+      callback = proc { |*args|
+        key = args.first.read_int
+        storage = @storage[key]
+        retval << storage
+
+        if block_given?
+          yield(storage)
+        end
+      }
 
       FFIGeos.GEOSSTRtree_query_r(
         Geos.current_handle,
@@ -98,12 +130,42 @@ module Geos
         nil
       )
 
-      if retval
-        retval.compact
-      end
       retval
     end
 
+    def query(geom, ret = :item)
+      self.query_all(geom).collect { |storage|
+        item = if ret.is_a?(Array)
+          storage.inject({}) do |memo, k|
+            memo.tap {
+              memo[k] = storage[k]
+            }
+          end
+        elsif ret == :all
+          storage
+        else
+          storage[ret]
+        end
+
+        item.tap {
+          if block_given?
+            yield(item)
+          end
+        }
+      }.compact
+    end
+
+    def query_geometries(geom)
+      self.query_all(geom).collect { |storage|
+        storage[:geometry].tap { |val|
+          if block_given?
+            yield(val)
+          end
+        }
+      }.compact
+    end
+    alias :query_geoms :query_geometries
+
     def iterate
       @storage.values.each do |v|
         yield(v)

data/lib/ffi-geos/utils.rb

@@ -63,16 +63,15 @@ module Geos
       end
 
       def create_polygon(outer, *inner)
-        inner = Array(inner).flatten.tap { |i|
-          if i.detect { |g| !g.is_a?(Geos::LinearRing) }
-            raise TypeError.new("Expected inner Array to contain Geometry::LinearRing objects")
-          end
+        inner_clones = Array(inner).flatten.collect { |i|
+          force_to_linear_ring(i) or
+            raise TypeError.new("Expected inner Array to contain Geos::LinearRing or Geos::CoordinateSequence objects")
         }
 
-        outer_clone = outer.clone
-        inner_clones = inner.map(&:clone)
+        outer_clone = force_to_linear_ring(outer) or
+          raise TypeError.new("Expected outer shell to be a Geos::LinearRing or Geos::CoordinateSequence")
 
-        ary = FFI::MemoryPointer.new(:pointer, inner.length)
+        ary = FFI::MemoryPointer.new(:pointer, inner_clones.length)
         ary.write_array_of_pointer(inner_clones.map(&:ptr))
 
         cast_geometry_ptr(FFIGeos.GEOSGeom_createPolygon_r(Geos.current_handle, outer_clone.ptr, ary, inner_clones.length)).tap {
@@ -161,6 +160,16 @@ module Geos
       def create_geometry_collection(*geoms)
         create_collection(:geometry_collection, *geoms)
       end
+
+      private
+        def force_to_linear_ring(geom)
+          case geom
+            when Geos::CoordinateSequence
+              geom.to_linear_ring
+            when Geos::LinearRing
+              geom.clone
+          end
+        end
     end
   end
 end

data/test/coordinate_sequence_tests.rb

@@ -7,21 +7,22 @@ class CoordinateSequenceTests < Test::Unit::TestCase
 
   def setup
     @cs = Geos::CoordinateSequence.new(3, 0)
+    super
   end
 
   def test_set_and_get_x
     @cs.set_x(0, 10.01)
-    assert_in_delta(10.01, @cs.get_x(0), 0.0000001)
+    assert_in_delta(10.01, @cs.get_x(0), TOLERANCE)
   end
 
   def test_set_and_get_y
     @cs.set_y(0, 20.02)
-    assert_in_delta(20.02, @cs.get_y(0), 0.0000001)
+    assert_in_delta(20.02, @cs.get_y(0), TOLERANCE)
   end
 
   def test_set_and_get_z
     @cs.set_z(0, 20.02)
-    assert_in_delta(20.02, @cs.get_z(0), 0.0000001)
+    assert_in_delta(20.02, @cs.get_z(0), TOLERANCE)
   end
 
   def test_set_and_get_ordinate
@@ -29,9 +30,9 @@ class CoordinateSequenceTests < Test::Unit::TestCase
     @cs.set_ordinate(0, 1, 20.02)
     @cs.set_ordinate(0, 2, 30.03)
 
-    assert_in_delta(10.01, @cs.get_ordinate(0, 0), 0.0000001)
-    assert_in_delta(20.02, @cs.get_ordinate(0, 1), 0.0000001)
-    assert_in_delta(30.03, @cs.get_ordinate(0, 2), 0.0000001)
+    assert_in_delta(10.01, @cs.get_ordinate(0, 0), TOLERANCE)
+    assert_in_delta(20.02, @cs.get_ordinate(0, 1), TOLERANCE)
+    assert_in_delta(30.03, @cs.get_ordinate(0, 2), TOLERANCE)
   end
 
   def test_length
@@ -89,4 +90,89 @@ class CoordinateSequenceTests < Test::Unit::TestCase
     assert_equal(@cs.get_y(0), cs_b.get_y(0))
     assert_equal(@cs.dimensions, cs_b.dimensions)
   end
+
+  def test_with_no_arguments
+    cs = Geos::CoordinateSequence.new
+    assert_equal(0, cs.size)
+    assert_equal(3, cs.dimensions)
+  end
+
+  def test_read_from_array
+    cs = Geos::CoordinateSequence.new([
+      [ 0, 0 ],
+      [ 1, 1 ],
+      [ 2, 2 ],
+      [ 3, 3 ],
+      [ 4, 4 ]
+    ])
+
+    assert_equal(2, cs.dimensions)
+    assert_equal(5, cs.length)
+
+    assert_raise(Geos::CoordinateSequence::ParseError) do
+      cs = Geos::CoordinateSequence.new([
+        [ 1, 2 ],
+        [ 1, 2, 3 ]
+      ])
+    end
+
+    assert_raise(Geos::CoordinateSequence::ParseError) do
+      cs = Geos::CoordinateSequence.new([
+        [ 1, 2, 3, 4 ]
+      ])
+    end
+  end
+
+  def test_to_to_linear_ring
+    cs = Geos::CoordinateSequence.new([
+      [ 0, 0 ],
+      [ 0, 5 ],
+      [ 5, 5 ],
+      [ 5, 0 ],
+      [ 0, 0 ]
+    ])
+
+    assert_equal('LINEARRING (0 0, 0 5, 5 5, 5 0, 0 0)', write(cs.to_linear_ring, :trim => true))
+  end
+
+  def test_to_empty_linear_ring
+    cs = Geos::CoordinateSequence.new
+
+    assert_equal('LINEARRING EMPTY', write(cs.to_linear_ring, :trim => true))
+  end
+
+  def test_to_line_string
+    cs = Geos::CoordinateSequence.new([
+      [ 0, 0 ],
+      [ 0, 5 ],
+      [ 5, 5 ],
+      [ 5, 0 ]
+    ])
+
+    assert_equal('LINESTRING (0 0, 0 5, 5 5, 5 0)', write(cs.to_line_string, :trim => true))
+  end
+
+  def test_to_empty_line_string
+    cs = Geos::CoordinateSequence.new
+
+    assert_equal('LINESTRING EMPTY', write(cs.to_line_string, :trim => true))
+  end
+
+  def test_to_polygon
+    cs = Geos::CoordinateSequence.new([
+      [ 0, 0 ],
+      [ 0, 5 ],
+      [ 5, 5 ],
+      [ 5, 0 ],
+      [ 0, 0 ]
+    ])
+
+    assert_equal('POLYGON ((0 0, 0 5, 5 5, 5 0, 0 0))', write(cs.to_polygon, :trim => true))
+  end
+
+  def test_to_empty_polygon
+    cs = Geos::CoordinateSequence.new
+
+    assert_equal('POLYGON EMPTY', write(cs.to_polygon, :trim => true))
+  end
 end

data/test/geometry_tests.rb

@@ -1530,4 +1530,18 @@ class GeometryTests < Test::Unit::TestCase
 
     assert(geom_a.eql?(geom_b))
   end
+
+  def test_geometry_collection_enumerator
+    geom = read('GEOMETRYCOLLECTION(POINT(0 0))')
+    assert_kind_of(Enumerable, geom.each)
+    assert_kind_of(Enumerable, geom.to_enum)
+    assert_equal(geom, geom.each {})
+  end
+
+  def test_line_string_enumerator
+    geom = read('LINESTRING(0 0, 10 10))')
+    assert_kind_of(Enumerable, geom.each)
+    assert_kind_of(Enumerable, geom.to_enum)
+    assert_equal(geom, geom.each {})
+  end
 end

data/test/strtree_tests.rb

@@ -34,10 +34,106 @@ if defined?(Geos::STRtree)
     def test_query
       setup_tree
 
-      assert_equal(1, @tree.query(read('LINESTRING(5 5, 6 6)')).length)
-      assert_equal(0, @tree.query(read('LINESTRING(20 0, 30 10)')).length)
-      assert_equal(2, @tree.query(read('LINESTRING(25 25, 26 26)')).length)
-      assert_equal(3, @tree.query(read('LINESTRING(0 0, 100 100)')).length)
+      assert_equal([@item_1],
+        @tree.query(read('LINESTRING(5 5, 6 6)')))
+
+      assert_equal([],
+        @tree.query(read('LINESTRING(20 0, 30 10)')))
+
+      assert_equal([@item_2, @item_3],
+        @tree.query(read('LINESTRING(25 25, 26 26)')))
+
+      assert_equal([@item_1, @item_2, @item_3],
+        @tree.query(read('LINESTRING(0 0, 100 100)')))
+    end
+
+    def test_query_with_ret_keys
+      setup_tree
+
+      assert_equal([@item_1],
+        @tree.query(read('LINESTRING(5 5, 6 6)'), :item))
+
+      assert_equal([],
+        @tree.query(read('LINESTRING(20 0, 30 10)'), :item))
+
+      assert_equal([@item_2, @item_3],
+        @tree.query(read('LINESTRING(25 25, 26 26)'), :item))
+
+      assert_equal([@item_1, @item_2, @item_3],
+        @tree.query(read('LINESTRING(0 0, 100 100)'), :item))
+
+
+      assert_equal([@geom_1],
+        @tree.query(read('LINESTRING(5 5, 6 6)'), :geometry))
+
+      assert_equal([],
+        @tree.query(read('LINESTRING(20 0, 30 10)'), :geometry))
+
+      assert_equal([@geom_2, @geom_3],
+        @tree.query(read('LINESTRING(25 25, 26 26)'), :geometry))
+
+      assert_equal([@geom_1, @geom_2, @geom_3],
+        @tree.query(read('LINESTRING(0 0, 100 100)'), :geometry))
+
+
+      assert_equal(
+        [
+          { :item => @item_1, :geometry => @geom_1 }
+        ],
+        @tree.query(read('LINESTRING(5 5, 6 6)'), :all)
+      )
+
+      assert_equal([],
+        @tree.query(read('LINESTRING(20 0, 30 10)'), :all))
+
+      assert_equal(
+        [
+          { :item => @item_2, :geometry => @geom_2 },
+          { :item => @item_3, :geometry => @geom_3 }
+        ],
+        @tree.query(read('LINESTRING(25 25, 26 26)'), :all)
+      )
+
+      assert_equal(
+        [
+          { :item => @item_1, :geometry => @geom_1 },
+          { :item => @item_2, :geometry => @geom_2 },
+          { :item => @item_3, :geometry => @geom_3 }
+        ],
+        @tree.query(read('LINESTRING(0 0, 100 100)'), :all)
+      )
+    end
+
+    def test_query_all
+      setup_tree
+
+      assert_equal([@item_1],
+        @tree.query_all(read('LINESTRING(5 5, 6 6)')).collect { |v| v[:item] })
+
+      assert_equal([],
+        @tree.query_all(read('LINESTRING(20 0, 30 10)')))
+
+      assert_equal([@item_2, @item_3],
+        @tree.query_all(read('LINESTRING(25 25, 26 26)')).collect { |v| v[:item] })
+
+      assert_equal([@item_1, @item_2, @item_3],
+        @tree.query_all(read('LINESTRING(0 0, 100 100)')).collect { |v| v[:item] })
+    end
+
+    def test_query_geometries
+      setup_tree
+
+      assert_equal([@geom_1],
+        @tree.query_geometries(read('LINESTRING(5 5, 6 6)')))
+
+      assert_equal([],
+        @tree.query_geometries(read('LINESTRING(20 0, 30 10)')))
+
+      assert_equal([@geom_2, @geom_3],
+        @tree.query_geometries(read('LINESTRING(25 25, 26 26)')))
+
+      assert_equal([@geom_1, @geom_2, @geom_3],
+        @tree.query_geometries(read('LINESTRING(0 0, 100 100)')))
     end
 
     def test_remove
@@ -45,10 +141,17 @@ if defined?(Geos::STRtree)
 
       @tree.remove(read('POINT(5 5)'), @item_1)
 
-      assert_equal(0, @tree.query(read('LINESTRING(5 5, 6 6)')).length)
-      assert_equal(0, @tree.query(read('LINESTRING(20 0, 30 10)')).length)
-      assert_equal(2, @tree.query(read('LINESTRING(25 25, 26 26)')).length)
-      assert_equal(2, @tree.query(read('LINESTRING(0 0, 100 100)')).length)
+      assert_equal([],
+        @tree.query(read('LINESTRING(5 5, 6 6)')))
+
+      assert_equal([],
+        @tree.query(read('LINESTRING(20 0, 30 10)')))
+
+      assert_equal([@item_2, @item_3],
+        @tree.query(read('LINESTRING(25 25, 26 26)')))
+
+      assert_equal([@item_2, @item_3],
+        @tree.query(read('LINESTRING(0 0, 100 100)')))
     end
 
     def test_cant_clone
@@ -62,5 +165,37 @@ if defined?(Geos::STRtree)
         Geos::STRtree.new(3).dup
       end
     end
+
+    def test_setup_with_array
+      tree = Geos::STRtree.new(
+        [ read('LINESTRING(0 0, 10 10)'), item_1 = { :item_1 => :test } ],
+        [ read('LINESTRING(20 20, 30 30)'), item_2 = [ :test ] ],
+        [ read('LINESTRING(20 20, 30 30)'), item_3 = Object.new ]
+      )
+
+      assert_equal([item_1],
+        tree.query(read('LINESTRING(5 5, 6 6)')))
+
+      assert_equal([],
+        tree.query(read('LINESTRING(20 0, 30 10)')))
+
+      assert_equal([item_2, item_3],
+        tree.query(read('LINESTRING(25 25, 26 26)')))
+
+      assert_equal([item_1, item_2, item_3],
+        tree.query(read('LINESTRING(0 0, 100 100)')))
+    end
+
+    def test_capacity
+      assert_raise(ArgumentError) do
+        Geos::STRtree.new(0)
+      end
+    end
+
+    def test_geometries
+      assert_raise(TypeError) do
+        Geos::STRtree.new([])
+      end
+    end
   end
 end

data/test/utils_tests.rb

@@ -131,66 +131,71 @@ class UtilsTests < Test::Unit::TestCase
   end
 
   def test_create_polygon
-    cs = Geos::CoordinateSequence.new(5, 2)
-    cs.set_x(0, 0)
-    cs.set_y(0, 0)
-
-    cs.set_x(1, 0)
-    cs.set_y(1, 10)
+    cs = Geos::CoordinateSequence.new([
+      [ 0, 0 ],
+      [ 0, 10 ],
+      [ 10, 10 ],
+      [ 10, 0 ],
+      [ 0, 0 ]
+    ])
 
-    cs.set_x(2, 10)
-    cs.set_y(2, 10)
+    exterior_ring = Geos::create_linear_ring(cs)
 
-    cs.set_x(3, 10)
-    cs.set_y(3, 0)
+    geom = Geos::create_polygon(exterior_ring)
+    assert_instance_of(Geos::Polygon, geom)
+    assert_equal('Polygon', geom.geom_type)
+    assert_equal(Geos::GEOS_POLYGON, geom.type_id)
+    assert_equal('POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))', write(geom, :trim => true))
+  end
 
-    cs.set_x(4, 0)
-    cs.set_y(4, 0)
+  def test_create_polygon_with_coordinate_sequences
+    outer = Geos::CoordinateSequence.new(
+      [ 0, 0 ],
+      [ 0, 10 ],
+      [ 10, 10 ],
+      [ 10, 0 ],
+      [ 0, 0 ]
+    )
 
-    exterior_ring = Geos::create_linear_ring(cs)
+    inner = Geos::CoordinateSequence.new(
+      [ 2, 2 ],
+      [ 2, 4 ],
+      [ 4, 4 ],
+      [ 4, 2 ],
+      [ 2, 2 ]
+    )
 
-    geom = Geos::create_polygon(exterior_ring)
+    geom = Geos::create_polygon(outer, inner)
     assert_instance_of(Geos::Polygon, geom)
     assert_equal('Polygon', geom.geom_type)
     assert_equal(Geos::GEOS_POLYGON, geom.type_id)
-    assert(read('POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0))').eql_exact?(geom, TOLERANCE))
+    assert_equal('POLYGON ((0 0, 0 10, 10 10, 10 0, 0 0), (2 2, 2 4, 4 4, 4 2, 2 2))', write(geom, :trim => true))
   end
 
   def test_create_polygon_with_holes
-    create_ring = lambda { |*points|
-      Geos.create_linear_ring(
-        Geos::CoordinateSequence.new(points.length, 2).tap { |cs|
-          points.each_with_index do |(x, y), i|
-            cs.set_x(i, x)
-            cs.set_y(i, y)
-          end
-        }
-      )
-    }
-
-    exterior_ring = create_ring[
+    exterior_ring = Geos::CoordinateSequence.new(
       [ 0, 0 ],
       [ 0, 10 ],
       [ 10, 10 ],
       [ 10, 0 ],
       [ 0, 0 ]
-    ]
+    )
 
-    hole_1 = create_ring[
+    hole_1 = Geos::CoordinateSequence.new(
       [ 2, 2 ],
       [ 2, 4 ],
       [ 4, 4 ],
       [ 4, 2 ],
       [ 2, 2 ]
-    ]
+    )
 
-    hole_2 = create_ring[
+    hole_2 = Geos::CoordinateSequence.new(
       [ 6, 6 ],
       [ 6, 8 ],
       [ 8, 8 ],
       [ 8, 6 ],
       [ 6, 6 ]
-    ]
+    )
 
     geom = Geos::create_polygon(exterior_ring, [ hole_1, hole_2 ])
     assert_instance_of(Geos::Polygon, geom)

metadata

@@ -1,32 +1,24 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: ffi-geos
-version: !ruby/object:Gem::Version 
-  hash: 29
+version: !ruby/object:Gem::Version
+  version: 0.0.2
   prerelease: 
-  segments: 
-  - 0
-  - 0
-  - 1
-  version: 0.0.1
 platform: ruby
-authors: 
+authors:
 - J Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2011-06-25 00:00:00 Z
+date: 2011-07-22 00:00:00.000000000 -04:00
+default_executable: 
 dependencies: []
-
 description: An ffi wrapper for GEOS, a C++ port of the Java Topology Suite (JTS).
 email: dark.panda@gmail.com
 executables: []
-
 extensions: []
-
-extra_rdoc_files: 
+extra_rdoc_files:
 - README.rdoc
-files: 
+files:
 - MIT-LICENSE
 - README.rdoc
 - Rakefile
@@ -64,38 +56,29 @@ files:
 - test/wkb_writer_tests.rb
 - test/wkt_reader_tests.rb
 - test/wkt_writer_tests.rb
+has_rdoc: true
 homepage: http://github.com/dark-panda/ffi-geos
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
 rubyforge_project: 
-rubygems_version: 1.7.2
+rubygems_version: 1.6.2
 signing_key: 
 specification_version: 3
 summary: An ffi wrapper for GEOS, a C++ port of the Java Topology Suite (JTS).
 test_files: []
-