rgeo 0.5.3 → 0.6.0

data/test/geos_capi/multi_line_string_test.rb

@@ -1,24 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the GEOS multi line string implementation
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-require ::File.expand_path("../common/multi_line_string_tests.rb", ::File.dirname(__FILE__))
-
-module RGeo
-  module Tests # :nodoc:
-    module GeosCAPI # :nodoc:
-      class TestMultiLineString < ::Test::Unit::TestCase # :nodoc:
-        def create_factory
-          ::RGeo::Geos.factory
-        end
-
-        include ::RGeo::Tests::Common::MultiLineStringTests
-      end
-    end
-  end
-end if ::RGeo::Geos.capi_supported?

data/test/geos_capi/multi_point_test.rb

@@ -1,24 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the GEOS multi point implementation
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-require ::File.expand_path("../common/multi_point_tests.rb", ::File.dirname(__FILE__))
-
-module RGeo
-  module Tests # :nodoc:
-    module GeosCAPI # :nodoc:
-      class TestMultiPoint < ::Test::Unit::TestCase # :nodoc:
-        def create_factory(opts_ = {})
-          ::RGeo::Geos.factory(opts_)
-        end
-
-        include ::RGeo::Tests::Common::MultiPointTests
-      end
-    end
-  end
-end if ::RGeo::Geos.capi_supported?

data/test/geos_capi/multi_polygon_test.rb

@@ -1,39 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the GEOS multi polygon implementation
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-require ::File.expand_path("../common/multi_polygon_tests.rb", ::File.dirname(__FILE__))
-
-module RGeo
-  module Tests # :nodoc:
-    module GeosCAPI # :nodoc:
-      class TestMultiPolygon < ::Test::Unit::TestCase # :nodoc:
-        def create_factories
-          @factory = ::RGeo::Geos.factory
-          @lenient_factory = ::RGeo::Geos.factory(lenient_multi_polygon_assertions: true)
-        end
-
-        include ::RGeo::Tests::Common::MultiPolygonTests
-
-        # Centroid of an empty should return an empty collection rather than crash
-
-        def test_empty_centroid
-          assert_equal(@factory.collection([]), @factory.multi_polygon([]).centroid)
-        end
-
-        def _test_geos_bug_582
-          f_ = ::RGeo::Geos.factory(buffer_resolution: 2)
-          p1_ = f_.polygon(f_.linear_ring([]))
-          p2_ = f_.polygon(f_.linear_ring([f_.point(0, 0), f_.point(0, 1), f_.point(1, 1), f_.point(1, 0)]))
-          mp_ = f_.multi_polygon([p2_, p1_])
-          mp_.centroid.as_text
-        end
-      end
-    end
-  end
-end if ::RGeo::Geos.capi_supported?

data/test/geos_capi/parsing_unparsing_test.rb

@@ -1,40 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the GEOS point implementation
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-module RGeo
-  module Tests # :nodoc:
-    module GeosCAPI # :nodoc:
-      class TestParsingUnparsing < ::Test::Unit::TestCase # :nodoc:
-        def test_wkt_generator_default_floating_point
-          # Bug report GH-4
-          factory_ = ::RGeo::Geos.factory
-          point_ = factory_.point(111.99, -40.37)
-          assert_equal("POINT (111.99 -40.37)", point_.as_text)
-        end
-
-        def test_wkt_generator_downcase
-          factory_ = ::RGeo::Geos.factory(wkt_generator: { convert_case: :lower })
-          point_ = factory_.point(1, 1)
-          assert_equal("point (1.0 1.0)", point_.as_text)
-        end
-
-        def test_wkt_generator_geos
-          factory_ = ::RGeo::Geos.factory(wkt_generator: :geos)
-          point_ = factory_.point(1, 1)
-          assert_equal("POINT (1.0000000000000000 1.0000000000000000)", point_.as_text)
-        end
-
-        def test_wkt_parser_default_with_non_geosable_input
-          factory_ = ::RGeo::Geos.factory
-          assert_not_nil(factory_.parse_wkt("Point (1 1)"))
-        end
-      end
-    end
-  end
-end if ::RGeo::Geos.capi_supported?

data/test/geos_capi/point_test.rb

@@ -1,72 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the GEOS point implementation
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-require ::File.expand_path("../common/point_tests.rb", ::File.dirname(__FILE__))
-
-module RGeo
-  module Tests # :nodoc:
-    module GeosCAPI # :nodoc:
-      class TestPoint < ::Test::Unit::TestCase # :nodoc:
-        def setup
-          @factory = ::RGeo::Geos.factory(buffer_resolution: 8)
-          @zfactory = ::RGeo::Geos.factory(has_z_coordinate: true)
-          @mfactory = ::RGeo::Geos.factory(has_m_coordinate: true)
-          @zmfactory = ::RGeo::Geos.factory(has_z_coordinate: true, has_m_coordinate: true)
-        end
-
-        include ::RGeo::Tests::Common::PointTests
-
-        def test_is_geos
-          point_ = @factory.point(21, -22)
-          assert_equal(true, ::RGeo::Geos.is_geos?(point_))
-          assert_equal(true, ::RGeo::Geos.is_capi_geos?(point_))
-          assert_equal(false, ::RGeo::Geos.is_ffi_geos?(point_))
-          point2_ = @zmfactory.point(21, -22, 0, 0)
-          assert_equal(true, ::RGeo::Geos.is_geos?(point2_))
-          assert_equal(true, ::RGeo::Geos.is_capi_geos?(point2_))
-          assert_equal(false, ::RGeo::Geos.is_ffi_geos?(point2_))
-        end
-
-        def test_has_no_projection
-          point_ = @factory.point(21, -22)
-          assert(!point_.respond_to?(:projection))
-        end
-
-        def test_srid
-          point_ = @factory.point(11, 12)
-          assert_equal(0, point_.srid)
-        end
-
-        def test_distance
-          point1_ = @factory.point(11, 12)
-          point2_ = @factory.point(11, 12)
-          point3_ = @factory.point(13, 12)
-          assert_equal(0, point1_.distance(point2_))
-          assert_equal(2, point1_.distance(point3_))
-        end
-
-        if defined?(::Encoding)
-
-          def test_as_text_encoding
-            factory_ = ::RGeo::Geos.factory(wkt_generator: :geos)
-            point_ = factory_.point(11, 12)
-            assert_equal(::Encoding::US_ASCII, point_.as_text.encoding)
-          end
-
-          def test_as_binary_encoding
-            factory_ = ::RGeo::Geos.factory(wkb_generator: :geos)
-            point_ = factory_.point(11, 12)
-            assert_equal(::Encoding::ASCII_8BIT, point_.as_binary.encoding)
-          end
-
-        end
-      end
-    end
-  end
-end if ::RGeo::Geos.capi_supported?

data/test/geos_capi/polygon_test.rb

@@ -1,154 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the GEOS polygon implementation
-#
-# -----------------------------------------------------------------------------
-
-require 'test/unit'
-require 'rgeo'
-
-require ::File.expand_path('../common/polygon_tests.rb', ::File.dirname(__FILE__))
-
-module RGeo
-  module Tests # :nodoc:
-    module GeosCAPI # :nodoc:
-      class TestPolygon < ::Test::Unit::TestCase # :nodoc:
-        def setup
-          @factory = ::RGeo::Geos.factory
-        end
-
-        include ::RGeo::Tests::Common::PolygonTests
-
-        def test_intersection
-          point1_ = @factory.point(0, 0)
-          point2_ = @factory.point(0, 2)
-          point3_ = @factory.point(2, 2)
-          point4_ = @factory.point(2, 0)
-          poly1_ = @factory.polygon(@factory.linear_ring([point1_, point2_, point3_, point4_]))
-          poly2_ = @factory.polygon(@factory.linear_ring([point1_, point2_, point4_]))
-          poly3_ = poly1_.intersection(poly2_)
-          assert_equal(poly2_, poly3_)
-        end
-
-        def test_union
-          point1_ = @factory.point(0, 0)
-          point2_ = @factory.point(0, 2)
-          point3_ = @factory.point(2, 2)
-          point4_ = @factory.point(2, 0)
-          poly1_ = @factory.polygon(@factory.linear_ring([point1_, point2_, point3_, point4_]))
-          poly2_ = @factory.polygon(@factory.linear_ring([point1_, point2_, point4_]))
-          poly3_ = poly1_.union(poly2_)
-          assert_equal(poly1_, poly3_)
-        end
-
-        def test_simplify
-          xys = [[0, 0], [5, 0], [10, 0], [10, 10], [5, 10.2], [0, 10], [0, 0]]
-          points = xys.collect { |x, y| @factory.point(x, y) }
-          poly = @factory.polygon(@factory.linear_ring(points))
-          simplified = poly.simplify(0.3)
-          new_points = simplified.exterior_ring.points
-          extra = new_points.reject { |p| [0, 10].include?(p.x) and [0, 10].include?(p.y) }
-          assert_equal 5, new_points.length, "Closed ring of the square should have 5 points"
-          assert_equal 0, extra.length, "Should only have x/y's on 0 and 10"
-        end
-
-        def test_buffer
-          polygon_coordinates = [[0.5527864045000421, 3.776393202250021],
-                                 [0.7763932022500211, 4.447213595499958],
-                                 [1.4472135954999579, 4.223606797749979],
-                                 [2.447213595499958, 2.223606797749979],
-                                 [2.223606797749979, 1.5527864045000421],
-                                 [1.5527864045000421, 1.776393202250021],
-                                 [0.5527864045000421, 3.776393202250021]]
-
-          points_arr = polygon_coordinates.map { |v| @factory.point(v[0], v[1]) }
-          outer_ring = @factory.linear_ring(points_arr)
-          polygon = @factory.polygon(outer_ring)
-
-          point1 = @factory.point(2, 2)
-          point2 = @factory.point(1, 4)
-          line_string = @factory.line_string([point1, point2])
-          polygon2 = line_string.buffer(0.5)
-
-          assert_equal polygon, polygon2
-        end
-
-        def test_simplify_preserve_topology()
-          xys1 = [[0.0, 0.0], [5.0, 0.0], [10.0, 0.0], [10.0, 10.0], [5.0, 12.0], [0.0, 10.0], [0.0, 0.0]]
-          xys2 = [[0.1, 0.1], [0.1, 0.6], [0.3, 0.8],  [0.5, 0.5],   [0.7, 0.3],  [0.3, 0.1],  [0.1, 0.1]]
-          
-          points1 = xys1.collect { |x,y| @factory.point(x, y) }
-          points2 = xys2.collect { |x,y| @factory.point(x, y) }
-          
-          ln1 = @factory.line_string(points1)
-          ln2 = @factory.line_string(points2)
-
-          poly = @factory.polygon(ln1,[ln2])
-
-          simplified = poly.simplify_preserve_topology(1)
-          interior_points = simplified.interior_rings[0].points
-
-          assert_equal 5, interior_points.length
-        end
-
-        def test_buffer_with_style
-          polygon_coordinates = [[0.7316718427000253, 3.865835921350013],
-                                 [1.0, 4.3], [6.0, 4.3], [6.3, 4.3],
-                                 [6.3, 3.7], [1.4854101966249682, 3.7],
-                                 [2.2683281572999747, 2.134164078649987],
-                                 [2.4024922359499623, 1.8658359213500124],
-                                 [1.8658359213500126, 1.597507764050038],
-                                 [0.7316718427000253, 3.865835921350013]]
-
-          points_arr = polygon_coordinates.map { |v| @factory.point(v[0], v[1]) }
-          outer_ring = @factory.linear_ring(points_arr)
-          polygon = @factory.polygon(outer_ring)
-
-          point1 = @factory.point(2, 2)
-          point2 = @factory.point(1, 4)
-          point3 = @factory.point(6, 4)
-          line_string = @factory.line_string([point1, point2, point3])
-          buffered_line_string = line_string.buffer_with_style(0.3,
-                                                                 RGeo::Geos::CAP_FLAT,
-                                                                 RGeo::Geos::JOIN_ROUND,
-                                                                 0.0)
-
-          assert_equal polygon, buffered_line_string
-        end
-
-        def test_is_valid_polygon
-          polygon_coordinates = [[0, 0], [0, 5], [5, 5], [5, 0], [0, 0]]
-          points_arr = polygon_coordinates.map{|v| @factory.point(v[0],v[1])}
-          outer_ring = @factory.linear_ring(points_arr)
-          polygon = @factory.polygon(outer_ring)
-          
-          assert_equal(polygon.valid?, true)
-                               
-          polygon_coordinates  = [[-1, -1], [-1, 0], [1, 0], [1, 1], [0, 1], [0, -1], [-1, -1]]
-          points_arr = polygon_coordinates.map{|v| @factory.point(v[0],v[1])}
-          outer_ring = @factory.linear_ring(points_arr)
-          polygon = @factory.polygon(outer_ring)
-          
-          assert_equal(polygon.valid?, false)
-        end
-
-        def test_invalid_reason
-          polygon_coordinates  = [[-1, -1], [-1, 0], [1, 0], [1, 1], [0, 1], [0, -1], [-1, -1]]
-          points_arr = polygon_coordinates.map{|v| @factory.point(v[0],v[1])}
-          outer_ring = @factory.linear_ring(points_arr)
-          polygon = @factory.polygon(outer_ring)
-
-          assert_equal(polygon.invalid_reason, "Self-intersection[0 0 0]")  
-        end
-
-        def test_invalid_reason_with_valid_polygon
-          polygon_coordinates = [[0, 0], [0, 5], [5, 5], [5, 0], [0, 0]]
-          points_arr = polygon_coordinates.map{|v| @factory.point(v[0],v[1])}
-          outer_ring = @factory.linear_ring(points_arr)
-          polygon = @factory.polygon(outer_ring)
-          polygon.invalid_reason
-        end
-      end
-    end
-  end
-end if ::RGeo::Geos.capi_supported?

data/test/geos_capi/zmfactory_test.rb

@@ -1,57 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the GEOS point implementation
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-require ::File.expand_path("../common/factory_tests.rb", ::File.dirname(__FILE__))
-
-module RGeo
-  module Tests # :nodoc:
-    module GeosCAPI # :nodoc:
-      class TestZMFactory < ::Test::Unit::TestCase # :nodoc:
-        def setup
-          @factory = ::RGeo::Geos.factory(has_z_coordinate: true, has_m_coordinate: true, srid: 1000, buffer_resolution: 2)
-          @srid = 1000
-        end
-
-        include ::RGeo::Tests::Common::FactoryTests
-
-        def test_is_geos_factory
-          assert_equal(true, ::RGeo::Geos.is_geos?(@factory))
-          assert_equal(true, ::RGeo::Geos.is_capi_geos?(@factory))
-          assert_equal(false, ::RGeo::Geos.is_ffi_geos?(@factory))
-        end
-
-        def test_factory_parts
-          assert_equal(1000, @factory.srid)
-          assert_equal(1000, @factory.z_factory.srid)
-          assert_equal(1000, @factory.m_factory.srid)
-          assert_equal(2, @factory.buffer_resolution)
-          assert_equal(2, @factory.z_factory.buffer_resolution)
-          assert_equal(2, @factory.m_factory.buffer_resolution)
-          assert(@factory.property(:has_z_coordinate))
-          assert(@factory.property(:has_m_coordinate))
-          assert(@factory.z_factory.property(:has_z_coordinate))
-          assert(!@factory.z_factory.property(:has_m_coordinate))
-          assert(!@factory.m_factory.property(:has_z_coordinate))
-          assert(@factory.m_factory.property(:has_m_coordinate))
-        end
-
-        def test_4d_point
-          point_ = @factory.point(1, 2, 3, 4)
-          assert_equal(Feature::Point, point_.geometry_type)
-          assert_equal(3, point_.z)
-          assert_equal(4, point_.m)
-          assert_equal(3, point_.z_geometry.z)
-          assert_nil(point_.z_geometry.m)
-          assert_nil(point_.m_geometry.z)
-          assert_equal(4, point_.m_geometry.m)
-        end
-      end
-    end
-  end
-end if ::RGeo::Geos.capi_supported?

data/test/geos_ffi/factory_test.rb

@@ -1,31 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the GEOS factory
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-require ::File.expand_path("../common/factory_tests.rb", ::File.dirname(__FILE__))
-
-module RGeo
-  module Tests # :nodoc:
-    module GeosFFI # :nodoc:
-      class TestFactory < ::Test::Unit::TestCase # :nodoc:
-        def setup
-          @factory = ::RGeo::Geos.factory(srid: 1000, native_interface: :ffi)
-          @srid = 1000
-        end
-
-        include ::RGeo::Tests::Common::FactoryTests
-
-        def test_is_geos_factory
-          assert_equal(true, ::RGeo::Geos.is_geos?(@factory))
-          assert_equal(false, ::RGeo::Geos.is_capi_geos?(@factory))
-          assert_equal(true, ::RGeo::Geos.is_ffi_geos?(@factory))
-        end
-      end
-    end
-  end
-end if ::RGeo::Geos.ffi_supported?