rgeo 0.5.3 → 0.6.0

data/test/geos_ffi/geometry_collection_test.rb

@@ -1,24 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the GEOS geometry collection implementation
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-require ::File.expand_path("../common/geometry_collection_tests.rb", ::File.dirname(__FILE__))
-
-module RGeo
-  module Tests # :nodoc:
-    module GeosFFI # :nodoc:
-      class TestGeometryCollection < ::Test::Unit::TestCase # :nodoc:
-        def create_factory
-          ::RGeo::Geos.factory(native_interface: :ffi)
-        end
-
-        include ::RGeo::Tests::Common::GeometryCollectionTests
-      end
-    end
-  end
-end if ::RGeo::Geos.ffi_supported?

data/test/geos_ffi/line_string_test.rb

@@ -1,24 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the GEOS line string implementation
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-require ::File.expand_path("../common/line_string_tests.rb", ::File.dirname(__FILE__))
-
-module RGeo
-  module Tests # :nodoc:
-    module GeosFFI # :nodoc:
-      class TestLineString < ::Test::Unit::TestCase # :nodoc:
-        def setup
-          @factory = ::RGeo::Geos.factory(native_interface: :ffi)
-        end
-
-        include ::RGeo::Tests::Common::LineStringTests
-      end
-    end
-  end
-end if ::RGeo::Geos.ffi_supported?

data/test/geos_ffi/misc_test.rb

@@ -1,63 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for miscellaneous GEOS stuff
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-module RGeo
-  module Tests # :nodoc:
-    module GeosFFI # :nodoc:
-      class TestMisc < ::Test::Unit::TestCase # :nodoc:
-        def setup
-          @factory = ::RGeo::Geos.factory(srid: 4326, native_interface: :ffi)
-        end
-
-        def test_empty_geometries_equal
-          geom1_ = @factory.collection([])
-          geom2_ = @factory.line_string([])
-          assert(!geom1_.eql?(geom2_))
-          assert(geom1_.equals?(geom2_))
-        end
-
-        def test_prepare
-          p1_ = @factory.point(1, 2)
-          p2_ = @factory.point(3, 4)
-          p3_ = @factory.point(5, 2)
-          polygon_ = @factory.polygon(@factory.linear_ring([p1_, p2_, p3_, p1_]))
-          assert_equal(false, polygon_.prepared?)
-          polygon_.prepare!
-          assert_equal(true, polygon_.prepared?)
-        end
-
-        def test_auto_prepare
-          p1_ = @factory.point(1, 2)
-          p2_ = @factory.point(3, 4)
-          p3_ = @factory.point(5, 2)
-          polygon_ = @factory.polygon(@factory.linear_ring([p1_, p2_, p3_, p1_]))
-          assert_equal(false, polygon_.prepared?)
-          polygon_.intersects?(p1_)
-          assert_equal(false, polygon_.prepared?)
-          polygon_.intersects?(p2_)
-          assert_equal(true, polygon_.prepared?)
-
-          factory_no_auto_prepare_ = ::RGeo::Geos.factory(srid: 4326,
-                                                          native_interface: :ffi, auto_prepare: :disabled)
-          polygon2_ = factory_no_auto_prepare_.polygon(
-            factory_no_auto_prepare_.linear_ring([p1_, p2_, p3_, p1_]))
-          assert_equal(false, polygon2_.prepared?)
-          polygon2_.intersects?(p1_)
-          assert_equal(false, polygon2_.prepared?)
-          polygon2_.intersects?(p2_)
-          assert_equal(false, polygon2_.prepared?)
-        end
-      end
-    end
-  end
-end if ::RGeo::Geos.ffi_supported?
-
-unless ::RGeo::Geos.ffi_supported?
-  puts "WARNING: FFI-GEOS support not available. Related tests skipped."
-end

data/test/geos_ffi/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 GeosFFI # :nodoc:
-      class TestMultiLineString < ::Test::Unit::TestCase # :nodoc:
-        def create_factory
-          ::RGeo::Geos.factory(native_interface: :ffi)
-        end
-
-        include ::RGeo::Tests::Common::MultiLineStringTests
-      end
-    end
-  end
-end if ::RGeo::Geos.ffi_supported?

data/test/geos_ffi/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 GeosFFI # :nodoc:
-      class TestMultiPoint < ::Test::Unit::TestCase # :nodoc:
-        def create_factory(opts_ = {})
-          ::RGeo::Geos.factory(opts_.merge(native_interface: :ffi))
-        end
-
-        include ::RGeo::Tests::Common::MultiPointTests
-      end
-    end
-  end
-end if ::RGeo::Geos.ffi_supported?

data/test/geos_ffi/multi_polygon_test.rb

@@ -1,33 +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 GeosFFI # :nodoc:
-      class TestMultiPolygon < ::Test::Unit::TestCase # :nodoc:
-        def create_factories
-          @factory = ::RGeo::Geos.factory(native_interface: :ffi)
-          @lenient_factory = ::RGeo::Geos.factory(lenient_multi_polygon_assertions: true,
-                                                  native_interface: :ffi)
-        end
-
-        include ::RGeo::Tests::Common::MultiPolygonTests
-
-        # Centroid of an empty should return an empty collection
-        # rather than throw a weird exception out of ffi-geos
-
-        def test_empty_centroid
-          assert_equal(@factory.collection([]), @factory.multi_polygon([]).centroid)
-        end
-      end
-    end
-  end
-end if ::RGeo::Geos.ffi_supported?

data/test/geos_ffi/parsing_unparsing_test.rb

@@ -1,41 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for the GEOS point implementation
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-module RGeo
-  module Tests # :nodoc:
-    module GeosFFI # :nodoc:
-      class TestParsingUnparsing < ::Test::Unit::TestCase # :nodoc:
-        def test_wkt_generator_default_floating_point
-          # Bug report GH-4
-          factory_ = ::RGeo::Geos.factory(native_interface: :ffi)
-          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 },
-                                          native_interface: :ffi)
-          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, native_interface: :ffi)
-          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(native_interface: :ffi)
-          assert_not_nil(factory_.parse_wkt("Point (1 1)"))
-        end
-      end
-    end
-  end
-end if ::RGeo::Geos.ffi_supported?

data/test/geos_ffi/point_test.rb

@@ -1,77 +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 GeosFFI # :nodoc:
-      class TestPoint < ::Test::Unit::TestCase # :nodoc:
-        def setup
-          @factory = ::RGeo::Geos.factory(native_interface: :ffi, buffer_resolution: 8)
-          @zfactory = ::RGeo::Geos.factory(has_z_coordinate: true, native_interface: :ffi)
-          @mfactory = ::RGeo::Geos.factory(has_m_coordinate: true, native_interface: :ffi)
-          @zmfactory = ::RGeo::Geos.factory(has_z_coordinate: true, has_m_coordinate: true,
-                                            native_interface: :ffi)
-        end
-
-        include ::RGeo::Tests::Common::PointTests
-
-        # TEMP until ffi-geos 0.0.5 is released
-        undef_method :test_buffer
-        # END_TEMP
-
-        def test_is_geos
-          point_ = @factory.point(21, -22)
-          assert_equal(true, ::RGeo::Geos.is_geos?(point_))
-          assert_equal(false, ::RGeo::Geos.is_capi_geos?(point_))
-          assert_equal(true, ::RGeo::Geos.is_ffi_geos?(point_))
-          point2_ = @zmfactory.point(21, -22, 0, 0)
-          assert_equal(true, ::RGeo::Geos.is_geos?(point2_))
-          assert_equal(false, ::RGeo::Geos.is_capi_geos?(point2_))
-          assert_equal(true, ::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(native_interface: :ffi, 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(native_interface: :ffi, 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.ffi_supported?

data/test/geos_ffi/polygon_test.rb

@@ -1,46 +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 GeosFFI # :nodoc:
-      class TestPolygon < ::Test::Unit::TestCase # :nodoc:
-        def setup
-          @factory = ::RGeo::Geos.factory(native_interface: :ffi)
-        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
-      end
-    end
-  end
-end if ::RGeo::Geos.ffi_supported?

data/test/geos_ffi/zmfactory_test.rb

@@ -1,58 +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 GeosFFI # :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, 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
-
-        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.ffi_supported?

data/test/mixins_test.rb

@@ -1,141 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for mixin system
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-module RGeo
-  module Tests # :nodoc:
-    class TestMixins < ::Test::Unit::TestCase # :nodoc:
-      module Mixin1  # :nodoc:
-        def mixin1_method
-        end
-      end
-
-      module Mixin2  # :nodoc:
-        def mixin2_method
-        end
-      end
-
-      ::RGeo::Feature::MixinCollection::GLOBAL.for_type(::RGeo::Feature::Point).add(Mixin1)
-      ::RGeo::Feature::MixinCollection::GLOBAL.for_type(::RGeo::Feature::GeometryCollection).add(Mixin1)
-      ::RGeo::Feature::MixinCollection::GLOBAL.for_type(::RGeo::Feature::MultiCurve).add(Mixin2)
-
-      def test_basic_mixin_cartesian
-        factory_ = ::RGeo::Cartesian.simple_factory
-        assert_equal(::RGeo::Cartesian::PointImpl, factory_.point(1, 1).class)
-        assert(factory_.point(1, 1).class.include?(Mixin1))
-        assert(!factory_.point(1, 1).class.include?(Mixin2))
-        assert(factory_.point(1, 1).respond_to?(:mixin1_method))
-        assert(!factory_.point(1, 1).respond_to?(:mixin2_method))
-      end
-
-      def test_inherited_mixin_cartesian
-        factory_ = ::RGeo::Cartesian.simple_factory
-        assert(factory_.collection([]).class.include?(Mixin1))
-        assert(!factory_.collection([]).class.include?(Mixin2))
-        assert(factory_.collection([]).respond_to?(:mixin1_method))
-        assert(!factory_.collection([]).respond_to?(:mixin2_method))
-        assert(factory_.multi_line_string([]).class.include?(Mixin1))
-        assert(factory_.multi_line_string([]).class.include?(Mixin2))
-        assert(factory_.multi_line_string([]).respond_to?(:mixin1_method))
-        assert(factory_.multi_line_string([]).respond_to?(:mixin2_method))
-      end
-
-      if ::RGeo::Geos.capi_supported?
-
-        def test_basic_mixin_geos_capi
-          factory_ = ::RGeo::Geos.factory(native_interface: :capi)
-          assert_equal(::RGeo::Geos::CAPIPointImpl, factory_.point(1, 1).class)
-          assert(factory_.point(1, 1).class.include?(Mixin1))
-          assert(!factory_.point(1, 1).class.include?(Mixin2))
-          assert(factory_.point(1, 1).respond_to?(:mixin1_method))
-          assert(!factory_.point(1, 1).respond_to?(:mixin2_method))
-        end
-
-        def test_inherited_mixin_geos_capi
-          factory_ = ::RGeo::Geos.factory(native_interface: :capi)
-          assert(factory_.collection([]).class.include?(Mixin1))
-          assert(!factory_.collection([]).class.include?(Mixin2))
-          assert(factory_.collection([]).respond_to?(:mixin1_method))
-          assert(!factory_.collection([]).respond_to?(:mixin2_method))
-          assert(factory_.multi_line_string([]).class.include?(Mixin1))
-          assert(factory_.multi_line_string([]).class.include?(Mixin2))
-          assert(factory_.multi_line_string([]).respond_to?(:mixin1_method))
-          assert(factory_.multi_line_string([]).respond_to?(:mixin2_method))
-        end
-
-      end
-
-      if ::RGeo::Geos.ffi_supported?
-
-        def test_basic_mixin_geos_ffi
-          factory_ = ::RGeo::Geos.factory(native_interface: :ffi)
-          assert_equal(::RGeo::Geos::FFIPointImpl, factory_.point(1, 1).class)
-          assert(factory_.point(1, 1).class.include?(Mixin1))
-          assert(!factory_.point(1, 1).class.include?(Mixin2))
-          assert(factory_.point(1, 1).respond_to?(:mixin1_method))
-          assert(!factory_.point(1, 1).respond_to?(:mixin2_method))
-        end
-
-        def test_inherited_mixin_geos_ffi
-          factory_ = ::RGeo::Geos.factory(native_interface: :ffi)
-          assert(factory_.collection([]).class.include?(Mixin1))
-          assert(!factory_.collection([]).class.include?(Mixin2))
-          assert(factory_.collection([]).respond_to?(:mixin1_method))
-          assert(!factory_.collection([]).respond_to?(:mixin2_method))
-          assert(factory_.multi_line_string([]).class.include?(Mixin1))
-          assert(factory_.multi_line_string([]).class.include?(Mixin2))
-          assert(factory_.multi_line_string([]).respond_to?(:mixin1_method))
-          assert(factory_.multi_line_string([]).respond_to?(:mixin2_method))
-        end
-
-      end
-
-      def test_basic_mixin_spherical
-        factory_ = ::RGeo::Geographic.spherical_factory
-        assert_equal(::RGeo::Geographic::SphericalPointImpl, factory_.point(1, 1).class)
-        assert(factory_.point(1, 1).class.include?(Mixin1))
-        assert(!factory_.point(1, 1).class.include?(Mixin2))
-        assert(factory_.point(1, 1).respond_to?(:mixin1_method))
-        assert(!factory_.point(1, 1).respond_to?(:mixin2_method))
-      end
-
-      def test_inherited_mixin_spherical
-        factory_ = ::RGeo::Geographic.spherical_factory
-        assert(factory_.collection([]).class.include?(Mixin1))
-        assert(!factory_.collection([]).class.include?(Mixin2))
-        assert(factory_.collection([]).respond_to?(:mixin1_method))
-        assert(!factory_.collection([]).respond_to?(:mixin2_method))
-        assert(factory_.multi_line_string([]).class.include?(Mixin1))
-        assert(factory_.multi_line_string([]).class.include?(Mixin2))
-        assert(factory_.multi_line_string([]).respond_to?(:mixin1_method))
-        assert(factory_.multi_line_string([]).respond_to?(:mixin2_method))
-      end
-
-      def test_basic_mixin_simple_mercator
-        factory_ = ::RGeo::Geographic.simple_mercator_factory
-        assert_equal(::RGeo::Geographic::ProjectedPointImpl, factory_.point(1, 1).class)
-        assert(factory_.point(1, 1).class.include?(Mixin1))
-        assert(!factory_.point(1, 1).class.include?(Mixin2))
-        assert(factory_.point(1, 1).respond_to?(:mixin1_method))
-        assert(!factory_.point(1, 1).respond_to?(:mixin2_method))
-      end
-
-      def test_inherited_mixin_simple_mercator
-        factory_ = ::RGeo::Geographic.simple_mercator_factory
-        assert(factory_.collection([]).class.include?(Mixin1))
-        assert(!factory_.collection([]).class.include?(Mixin2))
-        assert(factory_.collection([]).respond_to?(:mixin1_method))
-        assert(!factory_.collection([]).respond_to?(:mixin2_method))
-        assert(factory_.multi_line_string([]).class.include?(Mixin1))
-        assert(factory_.multi_line_string([]).class.include?(Mixin2))
-        assert(factory_.multi_line_string([]).respond_to?(:mixin1_method))
-        assert(factory_.multi_line_string([]).respond_to?(:mixin2_method))
-      end
-    end
-  end
-end