rgeo 0.5.3 → 0.6.0

data/lib/rgeo/yaml.rb

@@ -1,23 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# RGeo yaml support
-#
-# -----------------------------------------------------------------------------
-
-begin
-  require "psych"
-rescue ::LoadError
-end
-
-module RGeo
-  # :stopdoc:
-  PSYCH_AVAILABLE = defined?(::Psych)
-  # :startdoc:
-
-  # Returns true if YAML serialization and deserialization is supported.
-  # YAML support requires the Psych library/gem.
-
-  def self.yaml_supported?
-    PSYCH_AVAILABLE
-  end
-end

data/test/cartesian_analysis_test.rb

@@ -1,65 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for basic GeoJSON usage
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-module RGeo
-  module Tests # :nodoc:
-    class TestCartesianAnalysis < ::Test::Unit::TestCase # :nodoc:
-      def setup
-        @factory = ::RGeo::Cartesian.simple_factory
-      end
-
-      def test_ring_direction_clockwise_triangle
-        p1_ = @factory.point(1, 1)
-        p2_ = @factory.point(2, 4)
-        p3_ = @factory.point(5, 2)
-        ring_ = @factory.line_string([p1_, p2_, p3_, p1_])
-        assert_equal(-1, ::RGeo::Cartesian::Analysis.ring_direction(ring_))
-      end
-
-      def test_ring_direction_counterclockwise_triangle
-        p1_ = @factory.point(1, 1)
-        p2_ = @factory.point(2, 4)
-        p3_ = @factory.point(5, 2)
-        ring_ = @factory.line_string([p1_, p3_, p2_, p1_])
-        assert_equal(1, ::RGeo::Cartesian::Analysis.ring_direction(ring_))
-      end
-
-      def test_ring_direction_clockwise_puckered_quad
-        p1_ = @factory.point(1, 1)
-        p2_ = @factory.point(2, 6)
-        p3_ = @factory.point(3, 3)
-        p4_ = @factory.point(5, 2)
-        ring_ = @factory.line_string([p1_, p2_, p3_, p4_, p1_])
-        assert_equal(-1, ::RGeo::Cartesian::Analysis.ring_direction(ring_))
-      end
-
-      def test_ring_direction_counterclockwise_puckered_quad
-        p1_ = @factory.point(1, 1)
-        p2_ = @factory.point(2, 6)
-        p3_ = @factory.point(3, 3)
-        p4_ = @factory.point(5, 2)
-        ring_ = @factory.line_string([p1_, p4_, p3_, p2_, p1_])
-        assert_equal(1, ::RGeo::Cartesian::Analysis.ring_direction(ring_))
-      end
-
-      def test_ring_direction_counterclockwise_near_circle
-        p1_ = @factory.point(0, -3)
-        p2_ = @factory.point(2, -2)
-        p3_ = @factory.point(3, 0)
-        p4_ = @factory.point(2, 2)
-        p5_ = @factory.point(0, 3)
-        p6_ = @factory.point(-2, 2)
-        p7_ = @factory.point(-3, 0)
-        p8_ = @factory.point(-2, -2)
-        ring_ = @factory.line_string([p1_, p2_, p3_, p4_, p5_, p6_, p7_, p8_, p1_])
-        assert_equal(1, ::RGeo::Cartesian::Analysis.ring_direction(ring_))
-      end
-    end
-  end
-end

data/test/cartesian_bbox_test.rb

@@ -1,123 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Tests for basic GeoJSON usage
-#
-# -----------------------------------------------------------------------------
-
-require "test/unit"
-require "rgeo"
-
-module RGeo
-  module Tests # :nodoc:
-    class TestCartesianBBox < ::Test::Unit::TestCase # :nodoc:
-      def setup
-        @factory = ::RGeo::Cartesian.factory
-      end
-
-      def test_empty_bbox
-        bbox_ = ::RGeo::Cartesian::BoundingBox.new(@factory)
-        assert_equal(true, bbox_.empty?)
-        assert_equal(false, bbox_.has_z)
-        assert_nil(bbox_.min_x)
-        assert_equal(@factory, bbox_.factory)
-        assert_nil(bbox_.min_point)
-        assert_equal(true, bbox_.to_geometry.is_empty?)
-        assert_equal(true, bbox_.contains?(bbox_))
-        assert_equal(false, bbox_.contains?(@factory.point(1, 1)))
-        assert_nil(bbox_.center_x)
-        assert_equal(0, bbox_.x_span)
-        assert_equal(0, bbox_.subdivide.size)
-      end
-
-      def test_point_bbox
-        empty_bbox_ = ::RGeo::Cartesian::BoundingBox.new(@factory)
-        bbox_ = ::RGeo::Cartesian::BoundingBox.new(@factory)
-        bbox_.add(@factory.point(1, 2))
-        assert_equal(false, bbox_.empty?)
-        assert_equal(false, bbox_.has_z)
-        assert_equal(1.0, bbox_.min_x)
-        assert_equal(2.0, bbox_.min_y)
-        assert_equal(1.0, bbox_.max_x)
-        assert_equal(2.0, bbox_.max_y)
-        assert_equal(@factory, bbox_.factory)
-        assert_equal(@factory.point(1, 2), bbox_.min_point)
-        assert_equal(@factory.point(1, 2), bbox_.max_point)
-        assert_equal(@factory.point(1, 2), bbox_.to_geometry)
-        assert_equal(true, bbox_.contains?(empty_bbox_))
-        assert_equal(false, empty_bbox_.contains?(bbox_))
-        assert_equal(true, bbox_.contains?(@factory.point(1, 2)))
-        assert_equal(false, bbox_.contains?(@factory.point(2, 1)))
-        assert_equal(1, bbox_.center_x)
-        assert_equal(0, bbox_.x_span)
-        assert_equal(2, bbox_.center_y)
-        assert_equal(0, bbox_.y_span)
-        assert_equal([bbox_], bbox_.subdivide)
-      end
-
-      def test_rect_bbox
-        empty_bbox_ = ::RGeo::Cartesian::BoundingBox.new(@factory)
-        bbox_ = ::RGeo::Cartesian::BoundingBox.new(@factory)
-        bbox_.add(@factory.point(1, 4))
-        bbox_.add(@factory.point(2, 3))
-        assert_equal(false, bbox_.empty?)
-        assert_equal(false, bbox_.has_z)
-        assert_equal(1.0, bbox_.min_x)
-        assert_equal(3.0, bbox_.min_y)
-        assert_equal(2.0, bbox_.max_x)
-        assert_equal(4.0, bbox_.max_y)
-        assert_equal(@factory, bbox_.factory)
-        assert_equal(@factory.point(1, 3), bbox_.min_point)
-        assert_equal(@factory.point(2, 4), bbox_.max_point)
-        assert_equal(1.0, bbox_.to_geometry.area)
-        assert_equal(true, bbox_.contains?(empty_bbox_))
-        assert_equal(false, empty_bbox_.contains?(bbox_))
-        assert_equal(true, bbox_.contains?(@factory.point(1, 3)))
-        assert_equal(false, bbox_.contains?(@factory.point(2, 1)))
-        assert_equal(1.5, bbox_.center_x)
-        assert_equal(1, bbox_.x_span)
-        assert_equal(3.5, bbox_.center_y)
-        assert_equal(1, bbox_.y_span)
-      end
-
-      def test_bbox_from_points
-        bbox_ = ::RGeo::Cartesian::BoundingBox.new(@factory)
-        bbox_.add(@factory.point(1, 4))
-        bbox_.add(@factory.point(2, 3))
-        bbox2_ = ::RGeo::Cartesian::BoundingBox.create_from_points(
-          @factory.point(2, 3), @factory.point(1, 4))
-        assert_equal(bbox_, bbox2_)
-      end
-
-      def test_basic_rect_subdivide
-        bbox_ = ::RGeo::Cartesian::BoundingBox.new(@factory)
-        bbox_.add(@factory.point(1, 2))
-        bbox_.add(@factory.point(5, 4))
-        quads_ = bbox_.subdivide
-        quads_.each { |q_| assert_equal(2.0, q_.to_geometry.area) }
-        quadsum_ = quads_[0].to_geometry + quads_[1].to_geometry +
-          quads_[2].to_geometry + quads_[3].to_geometry
-        assert_equal(bbox_.to_geometry, quadsum_)
-      end
-
-      def test_horiz_line_subdivide
-        bbox_ = ::RGeo::Cartesian::BoundingBox.new(@factory)
-        bbox_.add(@factory.point(1, 2))
-        bbox_.add(@factory.point(5, 2))
-        lines_ = bbox_.subdivide
-        lines_.each { |line_| assert_equal(2.0, line_.to_geometry.length) }
-        linesum_ = lines_[0].to_geometry + lines_[1].to_geometry
-        assert_equal(bbox_.to_geometry, linesum_)
-      end
-
-      def test_vert_line_subdivide
-        bbox_ = ::RGeo::Cartesian::BoundingBox.new(@factory)
-        bbox_.add(@factory.point(1, 2))
-        bbox_.add(@factory.point(1, 6))
-        lines_ = bbox_.subdivide
-        lines_.each { |line_| assert_equal(2.0, line_.to_geometry.length) }
-        linesum_ = lines_[0].to_geometry + lines_[1].to_geometry
-        assert_equal(bbox_.to_geometry, linesum_)
-      end
-    end
-  end
-end

data/test/common/factory_tests.rb

@@ -1,78 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Common tests for geometry collection implementations
-#
-# -----------------------------------------------------------------------------
-
-require "rgeo"
-
-module RGeo
-  module Tests # :nodoc:
-    module Common # :nodoc:
-      module FactoryTests # :nodoc:
-        def _srid
-          defined?(@srid) ? @srid : 0
-        end
-
-        def test_srid_preserved_through_factory
-          geom_ = @factory.point(-10, 20)
-          assert_equal(_srid, geom_.srid)
-          factory_ = geom_.factory
-          assert_equal(_srid, factory_.srid)
-          geom2_ = factory_.point(-20, 25)
-          assert_equal(_srid, geom2_.srid)
-        end
-
-        def test_srid_preserved_through_geom_operations
-          geom1_ = @factory.point(-10, 20)
-          geom2_ = @factory.point(-20, 25)
-          geom3_ = geom1_.union(geom2_)
-          assert_equal(_srid, geom3_.srid)
-          assert_equal(_srid, geom3_.geometry_n(0).srid)
-          assert_equal(_srid, geom3_.geometry_n(1).srid)
-        end
-
-        def test_srid_preserved_through_geom_functions
-          geom1_ = @factory.point(-10, 20)
-          geom2_ = geom1_.boundary
-          assert_equal(_srid, geom2_.srid)
-        end
-
-        def test_srid_preserved_through_geometry_dup
-          geom1_ = @factory.point(-10, 20)
-          geom2_ = geom1_.clone
-          assert_equal(_srid, geom2_.srid)
-        end
-
-        def test_dup_factory_results_in_equal_factories
-          dup_factory_ = @factory.dup
-          assert_equal(@factory, dup_factory_)
-          assert_equal(_srid, dup_factory_.srid)
-        end
-
-        def test_dup_factory_results_in_equal_hashes
-          dup_factory_ = @factory.dup
-          assert_equal(@factory.hash, dup_factory_.hash)
-        end
-
-        def test_marshal_dump_load_factory
-          data_ = ::Marshal.dump(@factory)
-          factory2_ = ::Marshal.load(data_)
-          assert_equal(@factory, factory2_)
-          assert_equal(_srid, factory2_.srid)
-        end
-
-        if ::RGeo.yaml_supported?
-
-          def test_psych_dump_load_factory
-            data_ = ::Psych.dump(@factory)
-            factory2_ = ::Psych.load(data_)
-            assert_equal(@factory, factory2_)
-            assert_equal(_srid, factory2_.srid)
-          end
-
-        end
-      end
-    end
-  end
-end

data/test/common/geometry_collection_tests.rb

@@ -1,237 +0,0 @@
-# -----------------------------------------------------------------------------
-#
-# Common tests for geometry collection implementations
-#
-# -----------------------------------------------------------------------------
-
-require "rgeo"
-
-module RGeo
-  module Tests # :nodoc:
-    module Common # :nodoc:
-      module GeometryCollectionTests # :nodoc:
-        def setup
-          @factory = create_factory
-          @point1 = @factory.point(0, 0)
-          @point2 = @factory.point(1, 0)
-          @point3 = @factory.point(-4, 2)
-          @point4 = @factory.point(-5, 3)
-          @line1 = @factory.line_string([@point3, @point4])
-          @line2 = @factory.line_string([@point3, @point4, @point1])
-          @line3 = @factory.line(@point3, @point4)
-        end
-
-        def test_creation_simple
-          geom_ = @factory.collection([@point1, @line1])
-          assert_not_nil(geom_)
-          assert(::RGeo::Feature::GeometryCollection === geom_)
-          assert_equal(::RGeo::Feature::GeometryCollection, geom_.geometry_type)
-          assert_equal(2, geom_.num_geometries)
-          assert(@point1.eql?(geom_[0]))
-          assert(@line1.eql?(geom_[1]))
-        end
-
-        def test_creation_empty
-          geom_ = @factory.collection([])
-          assert_not_nil(geom_)
-          assert(::RGeo::Feature::GeometryCollection === geom_)
-          assert_equal(::RGeo::Feature::GeometryCollection, geom_.geometry_type)
-          assert_equal(0, geom_.num_geometries)
-          assert_equal([], geom_.to_a)
-        end
-
-        def test_bounds_check
-          geom_ = @factory.collection([@point1, @line1])
-          assert_nil(geom_.geometry_n(200))
-          assert_nil(geom_.geometry_n(-1))
-          assert(@line1.eql?(geom_[-1]))
-        end
-
-        def test_creation_save_klass
-          geom_ = @factory.collection([@point1, @line3])
-          assert_not_nil(geom_)
-          assert(::RGeo::Feature::GeometryCollection === geom_)
-          assert_equal(::RGeo::Feature::GeometryCollection, geom_.geometry_type)
-          assert_equal(2, geom_.num_geometries)
-          assert(geom_[1].eql?(@line3))
-        end
-
-        def test_creation_compound
-          geom1_ = @factory.collection([@point1, @line1])
-          geom2_ = @factory.collection([@point2, geom1_])
-          assert_not_nil(geom2_)
-          assert(::RGeo::Feature::GeometryCollection === geom2_)
-          assert_equal(::RGeo::Feature::GeometryCollection, geom2_.geometry_type)
-          assert_equal(2, geom2_.num_geometries)
-          assert(geom2_[1].eql?(geom1_))
-        end
-
-        def test_creation_compound_save_klass
-          geom1_ = @factory.collection([@point1, @line3])
-          geom2_ = @factory.collection([@point2, geom1_])
-          ::GC.start
-          assert_not_nil(geom2_)
-          assert(::RGeo::Feature::GeometryCollection === geom2_)
-          assert_equal(::RGeo::Feature::GeometryCollection, geom2_.geometry_type)
-          assert_equal(2, geom2_.num_geometries)
-          assert_equal(::RGeo::Feature::Line, geom2_[1][1].geometry_type)
-        end
-
-        def test_required_equivalences
-          geom1_ = @factory.collection([@point1, @line1])
-          geom2_ = @factory.collection([@point1, @line1])
-          assert(geom1_.eql?(geom2_))
-          assert(geom1_ == geom2_)
-        end
-
-        def test_fully_equal
-          geom1_ = @factory.collection([@point1, @line1])
-          geom2_ = @factory.collection([@point1, @line1])
-          assert(geom1_.rep_equals?(geom2_))
-          assert(geom1_.equals?(geom2_))
-        end
-
-        def test_geometrically_equal
-          geom1_ = @factory.collection([@point2, @line2])
-          geom2_ = @factory.collection([@point2, @line1, @line2])
-          assert(!geom1_.rep_equals?(geom2_))
-          assert(geom1_.equals?(geom2_))
-        end
-
-        def test_empty_equal
-          geom1_ = @factory.collection([])
-          geom2_ = @factory.collection([])
-          assert(geom1_.rep_equals?(geom2_))
-          assert(geom1_.equals?(geom2_))
-        end
-
-        def test_not_equal
-          geom1_ = @factory.collection([@point1, @line1])
-          geom2_ = @factory.collection([@point2, @line1])
-          assert(!geom1_.rep_equals?(geom2_))
-          assert(!geom1_.equals?(geom2_))
-        end
-
-        def test_hashes_equal_for_representationally_equivalent_objects
-          geom1_ = @factory.collection([@point1, @line1])
-          geom2_ = @factory.collection([@point1, @line1])
-          assert_equal(geom1_.hash, geom2_.hash)
-        end
-
-        def test_nested_equality
-          geom1_ = @factory.collection([@line1, @factory.collection([@point1, @point2])])
-          geom2_ = @factory.collection([@line1, @factory.collection([@point1, @point2])])
-          assert(geom1_.rep_equals?(geom2_))
-          assert_equal(geom1_.hash, geom2_.hash)
-        end
-
-        def test_out_of_order_is_not_equal
-          geom1_ = @factory.collection([@line1, @point2])
-          geom2_ = @factory.collection([@point2, @line1])
-          assert(!geom1_.rep_equals?(geom2_))
-          assert_not_equal(geom1_.hash, geom2_.hash)
-        end
-
-        def test_wkt_creation_simple
-          parsed_geom_ = @factory.parse_wkt("GEOMETRYCOLLECTION(POINT(0 0), LINESTRING(-4 2, -5 3))")
-          built_geom_ = @factory.collection([@point1, @line1])
-          assert(built_geom_.eql?(parsed_geom_))
-        end
-
-        def test_wkt_creation_empty
-          parsed_geom_ = @factory.parse_wkt("GEOMETRYCOLLECTION EMPTY")
-          assert_equal(0, parsed_geom_.num_geometries)
-          assert_equal([], parsed_geom_.to_a)
-        end
-
-        def test_clone
-          geom1_ = @factory.collection([@point1, @line1])
-          geom2_ = geom1_.clone
-          assert(geom1_.eql?(geom2_))
-          assert_equal(::RGeo::Feature::GeometryCollection, geom2_.geometry_type)
-          assert_equal(2, geom2_.num_geometries)
-          assert(@point1.eql?(geom2_[0]))
-          assert(@line1.eql?(geom2_[1]))
-        end
-
-        def test_type_check
-          geom1_ = @factory.collection([@point1, @line1])
-          assert(::RGeo::Feature::Geometry.check_type(geom1_))
-          assert(!::RGeo::Feature::Point.check_type(geom1_))
-          assert(::RGeo::Feature::GeometryCollection.check_type(geom1_))
-          assert(!::RGeo::Feature::MultiPoint.check_type(geom1_))
-          geom2_ = @factory.collection([@point1, @point2])
-          assert(::RGeo::Feature::Geometry.check_type(geom2_))
-          assert(!::RGeo::Feature::Point.check_type(geom2_))
-          assert(::RGeo::Feature::GeometryCollection.check_type(geom2_))
-          assert(!::RGeo::Feature::MultiPoint.check_type(geom2_))
-        end
-
-        def test_as_text_wkt_round_trip
-          geom1_ = @factory.collection([@point1, @line1])
-          text_ = geom1_.as_text
-          geom2_ = @factory.parse_wkt(text_)
-          assert(geom1_.eql?(geom2_))
-        end
-
-        def test_as_binary_wkb_round_trip
-          geom1_ = @factory.collection([@point1, @line1])
-          binary_ = geom1_.as_binary
-          geom2_ = @factory.parse_wkb(binary_)
-          assert(geom1_.eql?(geom2_))
-        end
-
-        def test_dimension
-          geom1_ = @factory.collection([@point1, @line1])
-          assert_equal(1, geom1_.dimension)
-          geom2_ = @factory.collection([@point1, @point2])
-          assert_equal(0, geom2_.dimension)
-          geom3_ = @factory.collection([])
-          assert_equal(-1, geom3_.dimension)
-        end
-
-        def test_is_empty
-          geom1_ = @factory.collection([@point1, @line1])
-          assert(!geom1_.is_empty?)
-          geom2_ = @factory.collection([])
-          assert(geom2_.is_empty?)
-        end
-
-        def test_empty_collection_envelope
-          empty_ = @factory.collection([])
-          envelope_ = empty_.envelope
-          assert_equal(Feature::GeometryCollection, envelope_.geometry_type)
-          assert_equal(0, envelope_.num_geometries)
-        end
-
-        def test_empty_collection_boundary
-          empty_ = @factory.collection([])
-          assert_nil(empty_.boundary)
-        end
-
-        def test_each_block
-          geom1_ = @factory.collection([@point1, @line1])
-          i_ = 0
-          geom1_.each do |g_|
-            if i_ == 0
-              assert_equal(@point1, g_)
-            else
-              assert_equal(@line1, g_)
-            end
-            i_ += 1
-          end
-        end
-
-        def test_each_enumerator
-          geom1_ = @factory.collection([@point1, @line1])
-          enum_ = geom1_.each
-          assert_equal(@point1, enum_.next)
-          assert_equal(@line1, enum_.next)
-          assert_raise(::StopIteration) do
-            enum_.next
-          end
-        end
-      end
-    end
-  end
-end