rgeo 0.4.0 → 0.5.0

data/test/simple_mercator/tc_polygon.rb

@@ -4,29 +4,21 @@
 #
 # -----------------------------------------------------------------------------
 
-require 'test/unit'
-require 'rgeo'
-
-require ::File.expand_path('../common/polygon_tests.rb', ::File.dirname(__FILE__))
+require "test/unit"
+require "rgeo"
 
+require ::File.expand_path("../common/polygon_tests.rb", ::File.dirname(__FILE__))
 
 module RGeo
-  module Tests  # :nodoc:
-    module SimpleMercator  # :nodoc:
-
-      class TestPolygon < ::Test::Unit::TestCase  # :nodoc:
-
-
+  module Tests # :nodoc:
+    module SimpleMercator # :nodoc:
+      class TestPolygon < ::Test::Unit::TestCase # :nodoc:
         def setup
           @factory = ::RGeo::Geographic.simple_mercator_factory
         end
 
-
         include ::RGeo::Tests::Common::PolygonTests
-
-
       end
-
     end
   end
 end

data/test/simple_mercator/tc_window.rb

@@ -4,41 +4,33 @@
 #
 # -----------------------------------------------------------------------------
 
-require 'test/unit'
-require 'rgeo'
-
+require "test/unit"
+require "rgeo"
 
 module RGeo
-  module Tests  # :nodoc:
-    module SimpleMercator  # :nodoc:
-
-      class TestWindow < ::Test::Unit::TestCase  # :nodoc:
-
-
+  module Tests # :nodoc:
+    module SimpleMercator # :nodoc:
+      class TestWindow < ::Test::Unit::TestCase # :nodoc:
         def setup
           @factory = ::RGeo::Geographic.simple_mercator_factory
         end
 
-
         def assert_close_enough(p1_, p2_)
           assert((p1_.x - p2_.x).abs < 0.00001 && (p1_.y - p2_.y).abs < 0.00001)
         end
 
-
         def assert_contains_approx(p_, mp_)
-          assert(mp_.any?{ |q_| (p_.x - q_.x).abs < 0.00001 && (p_.y - q_.y).abs < 0.00001 })
+          assert(mp_.any? { |q_| (p_.x - q_.x).abs < 0.00001 && (p_.y - q_.y).abs < 0.00001 })
         end
 
-
         def test_limits
           limits_ = @factory.projection_limits_window
-          assert_in_delta(-20037508, limits_.x_min, 1)
-          assert_in_delta(-20037508, limits_.y_min, 1)
-          assert_in_delta(20037508, limits_.x_max, 1)
-          assert_in_delta(20037508, limits_.y_max, 1)
+          assert_in_delta(-20_037_508, limits_.x_min, 1)
+          assert_in_delta(-20_037_508, limits_.y_min, 1)
+          assert_in_delta(20_037_508, limits_.x_max, 1)
+          assert_in_delta(20_037_508, limits_.y_max, 1)
         end
 
-
         def test_limits_unprojected
           limits_ = @factory.projection_limits_window
           assert_close_enough(@factory.point(-180, -85.051129), limits_.sw_point)
@@ -48,7 +40,6 @@ module RGeo
           assert_close_enough(@factory.point(0, 0), limits_.center_point)
         end
 
-
         def test_center_point
           window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(-160, -30), @factory.point(170, 30))
           assert_close_enough(@factory.point(5, 0), window1_.center_point)
@@ -56,7 +47,6 @@ module RGeo
           assert_close_enough(@factory.point(175, 0), window2_.center_point)
         end
 
-
         def test_random_point
           window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(-170, 30), @factory.point(-160, 40))
           20.times { assert(window1_.contains_point?(window1_.random_point)) }
@@ -64,7 +54,6 @@ module RGeo
           20.times { assert(window2_.contains_point?(window2_.random_point)) }
         end
 
-
         def test_crosses_seam
           window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(-170, 30), @factory.point(170, 40))
           assert(!window1_.crosses_seam?)
@@ -72,7 +61,6 @@ module RGeo
           assert(window2_.crosses_seam?)
         end
 
-
         def test_degenerate
           window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(-20, 30), @factory.point(-10, 40))
           assert(!window1_.degenerate?)
@@ -82,7 +70,6 @@ module RGeo
           assert(window3_.degenerate?)
         end
 
-
         def test_contains_point
           window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(-170, 30), @factory.point(-160, 40))
           window2_ = Geographic::ProjectedWindow.for_corners(@factory.point(170, 30), @factory.point(-170, 40))
@@ -100,7 +87,6 @@ module RGeo
           assert(!window2_.contains_point?(point5_))
         end
 
-
         def test_noseam_contains_window
           window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(10, 10), @factory.point(30, 30))
           assert(window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(15, 15), @factory.point(25, 25))))
@@ -120,7 +106,6 @@ module RGeo
           assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(170, 35), @factory.point(-170, 40))))
         end
 
-
         def test_seam_contains_window
           window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(160, 10), @factory.point(-160, 30))
           assert(window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(175, 15), @factory.point(-175, 25))))
@@ -136,7 +121,6 @@ module RGeo
           assert(!window1_.contains_window?(Geographic::ProjectedWindow.for_corners(@factory.point(150, 15), @factory.point(-150, 25))))
         end
 
-
         def test_scaled_by
           window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(20, -20), @factory.point(50, 40))
           window1s_ = window1_.scaled_by(2, 1.5)
@@ -146,7 +130,6 @@ module RGeo
           assert(!window1s_.contains_point?(@factory.point(10, -35)))
         end
 
-
         def test_scaled_by_across_seam
           window1_ = Geographic::ProjectedWindow.for_corners(@factory.point(170, -20), @factory.point(-160, 40))
           window1s_ = window1_.scaled_by(2, 1.5)
@@ -156,7 +139,6 @@ module RGeo
           assert(!window1s_.contains_point?(@factory.point(-140, 45)))
         end
 
-
         def test_surrounding_point
           window1_ = Geographic::ProjectedWindow.surrounding_point(@factory.point(20, -20), 1)
           assert(window1_.contains_point?(@factory.point(20, -20)))
@@ -164,7 +146,6 @@ module RGeo
           assert(!window1_.contains_point?(@factory.point(19, -20)))
         end
 
-
         def test_bounding_1_point
           window1_ = Geographic::ProjectedWindow.bounding_points([@factory.point(20, -20)]).with_margin(1)
           assert(window1_.contains_point?(@factory.point(20, -20)))
@@ -172,7 +153,6 @@ module RGeo
           assert(!window1_.contains_point?(@factory.point(19, -20)))
         end
 
-
         def test_bounding_2_points
           window1_ = Geographic::ProjectedWindow.bounding_points([@factory.point(10, 10), @factory.point(30, 30)])
           assert(window1_.contains_point?(@factory.point(20, 20)))
@@ -180,7 +160,6 @@ module RGeo
           assert(!window1_.contains_point?(@factory.point(20, 35)))
         end
 
-
         def test_bounding_2_points_across_seam
           window1_ = Geographic::ProjectedWindow.bounding_points([@factory.point(-170, 10), @factory.point(170, 30)])
           assert(window1_.contains_point?(@factory.point(-174, 20)))
@@ -188,10 +167,7 @@ module RGeo
           assert(!window1_.contains_point?(@factory.point(160, 20)))
           assert(!window1_.contains_point?(@factory.point(-174, 35)))
         end
-
-
       end
-
     end
   end
 end

data/test/spherical_geographic/tc_calculations.rb

@@ -4,17 +4,13 @@
 #
 # -----------------------------------------------------------------------------
 
-require 'test/unit'
-require 'rgeo'
-
+require "test/unit"
+require "rgeo"
 
 module RGeo
-  module Tests  # :nodoc:
-    module SphericalGeographic  # :nodoc:
-
-      class TestCalculations < ::Test::Unit::TestCase  # :nodoc:
-
-
+  module Tests # :nodoc:
+    module SphericalGeographic # :nodoc:
+      class TestCalculations < ::Test::Unit::TestCase # :nodoc:
         def assert_close_enough(v1_, v2_)
           diff_ = (v1_ - v2_).abs
           # denom_ = (v1_ + v2_).abs
@@ -22,14 +18,12 @@ module RGeo
           assert(diff_ < 0.00000001, "#{v1_} is not close to #{v2_}")
         end
 
-
         def test_point_eql
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
           assert_equal(point1_, point2_)
         end
 
-
         def test_point_from_latlng
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.from_latlon(45, -45)
           assert_close_enough(0.5, point1_.x)
@@ -37,70 +31,60 @@ module RGeo
           assert_close_enough(::Math.sqrt(2) * 0.5, point1_.z)
         end
 
-
         def test_point_dot_one
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 1, 1)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 1, 1)
           assert_close_enough(1.0, point1_ * point2_)
         end
 
-
         def test_point_dot_minusone
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 1, 1)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(-1, -1, -1)
           assert_close_enough(-1.0, point1_ * point2_)
         end
 
-
         def test_point_dot_zero
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 1, 0)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, -1, 0)
           assert_close_enough(0.0, point1_ * point2_)
         end
 
-
         def test_point_cross
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 1, 0)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, -1, 0)
           assert_close_enough(-1.0, (point1_ % point2_).z)
         end
 
-
         def test_point_cross_coincident
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
           assert_nil(point1_ % point2_)
         end
 
-
         def test_point_cross_opposite
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(-1, 0, 0)
           assert_nil(point1_ % point2_)
         end
 
-
         def test_distance_coincident
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
           assert_equal(0.0, point1_.dist_to_point(point2_))
         end
 
-
         def test_distance_opposite
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(-1, 0, 0)
           assert_close_enough(::Math::PI, point1_.dist_to_point(point2_))
         end
 
-
         def test_distance_right_angle
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, -1, 0)
           assert_close_enough(::Math::PI / 2, point1_.dist_to_point(point2_))
         end
 
-
         def test_arc_axis
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 1, 0)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, -1, 0)
@@ -108,7 +92,6 @@ module RGeo
           assert_close_enough(-1.0, arc1_.axis.z)
         end
 
-
         def test_arc_axis2
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0.000001, 0)
@@ -116,7 +99,6 @@ module RGeo
           assert_close_enough(1.0, arc1_.axis.z)
         end
 
-
         def test_arc_intersects_point_off
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0.000002, 0)
@@ -125,7 +107,6 @@ module RGeo
           assert_equal(false, arc1_.contains_point?(point3_))
         end
 
-
         def test_arc_intersects_point_between
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0.000002, 0)
@@ -134,7 +115,6 @@ module RGeo
           assert_equal(true, arc1_.contains_point?(point3_))
         end
 
-
         def test_arc_intersects_point_endpoint
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0, 0)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(1, 0.000002, 0)
@@ -142,7 +122,6 @@ module RGeo
           assert_equal(true, arc1_.contains_point?(point1_))
         end
 
-
         def test_arc_intersects_arc_true
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, 0.1, 1)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, -0.1, 1)
@@ -153,7 +132,6 @@ module RGeo
           assert_equal(true, arc1_.intersects_arc?(arc2_))
         end
 
-
         def test_arc_intersects_arc_parallel
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, 0.1, 1)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, -0.1, 1)
@@ -164,7 +142,6 @@ module RGeo
           assert_equal(false, arc1_.intersects_arc?(arc2_))
         end
 
-
         def test_arc_intersects_arc_separated_tee
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, 0.1, 1)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, -0.1, 1)
@@ -175,7 +152,6 @@ module RGeo
           assert_equal(false, arc1_.intersects_arc?(arc2_))
         end
 
-
         def test_arc_intersects_arc_connected_tee
           point1_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, 0.1, 1)
           point2_ = ::RGeo::Geographic::SphericalMath::PointXYZ.new(0, -0.1, 1)
@@ -185,10 +161,7 @@ module RGeo
           arc2_ = ::RGeo::Geographic::SphericalMath::ArcXYZ.new(point3_, point4_)
           assert_equal(true, arc1_.intersects_arc?(arc2_))
         end
-
-
       end
-
     end
   end
 end

data/test/spherical_geographic/tc_factory.rb

@@ -4,33 +4,24 @@
 #
 # -----------------------------------------------------------------------------
 
-require 'test/unit'
-require 'rgeo'
-
-require ::File.expand_path('../common/factory_tests.rb', ::File.dirname(__FILE__))
+require "test/unit"
+require "rgeo"
 
+require ::File.expand_path("../common/factory_tests.rb", ::File.dirname(__FILE__))
 
 module RGeo
-  module Tests  # :nodoc:
-    module SphericalGeographic  # :nodoc:
-
-      class TestFactory < ::Test::Unit::TestCase  # :nodoc:
-
-
+  module Tests # :nodoc:
+    module SphericalGeographic # :nodoc:
+      class TestFactory < ::Test::Unit::TestCase # :nodoc:
         def setup
           @factory = ::RGeo::Geographic.spherical_factory
           @srid = 4055
         end
 
-
         include ::RGeo::Tests::Common::FactoryTests
 
-
         undef_method :test_srid_preserved_through_geom_operations
-
-
       end
-
     end
   end
 end

data/test/spherical_geographic/tc_geometry_collection.rb

@@ -4,37 +4,28 @@
 #
 # -----------------------------------------------------------------------------
 
-require 'test/unit'
-require 'rgeo'
-
-require ::File.expand_path('../common/geometry_collection_tests.rb', ::File.dirname(__FILE__))
+require "test/unit"
+require "rgeo"
 
+require ::File.expand_path("../common/geometry_collection_tests.rb", ::File.dirname(__FILE__))
 
 module RGeo
-  module Tests  # :nodoc:
-    module SphericalGeographic  # :nodoc:
-
-      class TestGeometryCollection < ::Test::Unit::TestCase  # :nodoc:
-
-
+  module Tests # :nodoc:
+    module SphericalGeographic # :nodoc:
+      class TestGeometryCollection < ::Test::Unit::TestCase # :nodoc:
         def create_factory
           @factory = ::RGeo::Geographic.spherical_factory
         end
 
-
         include ::RGeo::Tests::Common::GeometryCollectionTests
 
-
         undef_method :test_fully_equal
         undef_method :test_geometrically_equal
         undef_method :test_empty_equal
         undef_method :test_not_equal
         undef_method :test_empty_collection_envelope
         undef_method :test_empty_collection_boundary
-
-
       end
-
     end
   end
 end