rgeo-dschee 0.5.4

data/lib/rgeo/yaml.rb

@@ -0,0 +1,23 @@
+# -----------------------------------------------------------------------------
+#
+# 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

@@ -0,0 +1,65 @@
+# -----------------------------------------------------------------------------
+#
+# 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

@@ -0,0 +1,123 @@
+# -----------------------------------------------------------------------------
+#
+# 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

@@ -0,0 +1,78 @@
+# -----------------------------------------------------------------------------
+#
+# 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

@@ -0,0 +1,237 @@
+# -----------------------------------------------------------------------------
+#
+# 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