terraformer 0.0.1 → 0.0.2

data/test/geometry_spec.rb

@@ -0,0 +1,1082 @@
+require_relative './helper'
+
+describe Terraformer::Geometry do
+
+  describe 'construction' do
+
+    describe Terraformer::Point do
+
+      it 'constructs from coordinate' do
+        c = Terraformer::Coordinate.new -122.6764, 45.5165
+        p = Terraformer::Point.new c
+        p.must_be_valid_geojson
+      end
+
+    end
+
+    describe Terraformer::MultiPoint do
+
+      it 'constructs from coordinates' do
+        a = Terraformer::Coordinate.new -122.6764, 45.5165
+        b = a + [0.02, 0.02]
+        mp = Terraformer::MultiPoint.new a, b
+        mp.must_be_valid_geojson
+      end
+
+      it 'constructs from Point objects' do
+        a = Terraformer::Coordinate.new -122.6764, 45.5165
+        b = a + [0.02, 0.02]
+        mp = Terraformer::MultiPoint.new a.to_point, b.to_point
+        mp.must_be_valid_geojson
+      end
+
+    end
+
+    describe Terraformer::LineString do
+
+      it 'constructs from coordinates' do
+        a = Terraformer::Coordinate.new -122.6764, 45.5165
+        b = a + [0.02, 0.02]
+        c = b + [0.1, -0.1]
+        ls = Terraformer::LineString.new a, b, c
+        ls.must_be_valid_geojson
+      end
+
+    end
+
+    describe Terraformer::MultiLineString do
+
+      it 'constructs from coordinates' do
+        a = Terraformer::Coordinate.new -122.6764, 45.5165
+        b = a + [0.02, 0.02]
+        c = b + [0.1, -0.1]
+        mls = Terraformer::MultiLineString.new a, b, c
+        mls.must_be_valid_geojson
+      end
+
+      it 'constructs from coordinates arrays' do
+        a = Terraformer::Coordinate.new -122.6764, 45.5165
+        b = a + [0.02, 0.02]
+        c = b + [0.1, -0.1]
+        d = c + [1,1]
+        e = d + [0.02, 0.02]
+        f = e + [0.1, -0.1]
+        mls = Terraformer::MultiLineString.new [a, b, c], [d, e, f]
+        mls.must_be_valid_geojson
+      end
+
+      it 'constructs from LineString objects' do
+        a = Terraformer::Coordinate.new -122.6764, 45.5165
+        b = a + [0.02, 0.02]
+        c = b + [0.1, -0.1]
+        d = c + [1,1]
+        e = d + [0.02, 0.02]
+        f = e + [0.1, -0.1]
+        ls_1 = Terraformer::LineString.new a, b, c
+        ls_2 = Terraformer::LineString.new d, e, f
+        mls = Terraformer::MultiLineString.new ls_1, ls_2
+        mls.must_be_valid_geojson
+      end
+
+    end
+
+    describe Terraformer::Polygon do
+
+      it 'constructs from coordinates' do
+        a = Terraformer::Coordinate.new -122.6764, 45.5165
+        b = a + [0, 0.02]
+        c = b + [0.02, 0]
+        d = c + [0, -0.02]
+        p = Terraformer::Polygon.new a, b, c, d, a
+        p.must_be_valid_geojson
+      end
+
+      it 'constructs from coordinates array' do
+        a = Terraformer::Coordinate.new -122.6764, 45.5165
+        b = a + [0, 0.02]
+        c = b + [0.02, 0]
+        d = c + [0, -0.02]
+        p = Terraformer::Polygon.new [a, b, c, d, a]
+        p.must_be_valid_geojson
+      end
+
+      it 'constructs with holes from coordinates arrays' do
+        a = Terraformer::Coordinate.new -122.6764, 45.5165
+        b = a + [0, 0.02]
+        c = b + [0.02, 0]
+        d = c + [0, -0.02]
+        hole = [
+          [ -122.67072200775145, 45.52438983143154 ],
+          [ -122.67072200775145, 45.53241707548722 ],
+          [ -122.6617956161499, 45.53241707548722 ],
+          [ -122.6617956161499, 45.52438983143154 ],
+          [ -122.67072200775145, 45.52438983143154 ]
+        ].map {|c| Terraformer::Coordinate.new c}
+        p = Terraformer::Polygon.new [a, b, c, d, a], hole
+        p.must_be_valid_geojson
+      end
+
+    end
+
+    describe Terraformer::MultiPolygon do
+
+      it 'constructs from coordinates' do
+        a = Terraformer::Coordinate.new -122.6764, 45.5165
+        b = a + [0, 0.02]
+        c = b + [0.02, 0]
+        d = c + [0, -0.02]
+        mp = Terraformer::MultiPolygon.new a, b, c, d, a
+        mp.must_be_valid_geojson
+      end
+
+      it 'constructs from coordinates array' do
+        a = Terraformer::Coordinate.new -122.6764, 45.5165
+        b = a + [0, 0.02]
+        c = b + [0.02, 0]
+        d = c + [0, -0.02]
+        mp = Terraformer::MultiPolygon.new [a, b, c, d, a]
+        mp.must_be_valid_geojson
+      end
+
+      it 'constructs with holes from coordinates arrays' do
+        a = Terraformer::Coordinate.new -122.6764, 45.5165
+        b = a + [0, 0.02]
+        c = b + [0.02, 0]
+        d = c + [0, -0.02]
+        hole = [
+          [ -122.67072200775145, 45.52438983143154 ],
+          [ -122.67072200775145, 45.53241707548722 ],
+          [ -122.6617956161499, 45.53241707548722 ],
+          [ -122.6617956161499, 45.52438983143154 ],
+          [ -122.67072200775145, 45.52438983143154 ]
+        ].map {|c| Terraformer::Coordinate.new c}
+        mp = Terraformer::MultiPolygon.new [a, b, c, d, a], hole
+        mp.must_be_valid_geojson
+      end
+
+      it 'constructs from Polygon objects' do
+        a = Terraformer::Coordinate.new -122.6764, 45.5165
+        b = a + [0, 0.02]
+        c = b + [0.02, 0]
+        d = c + [0, -0.02]
+        p_1 = Terraformer::Polygon.new a, b, c, d, a
+        e = Terraformer::Coordinate.new -122.6764, 45.5165
+        f = a + [0, 0.02]
+        g = b + [0.02, 0]
+        h = c + [0, -0.02]
+        hole = [
+          [ -122.67072200775145, 45.52438983143154 ],
+          [ -122.67072200775145, 45.53241707548722 ],
+          [ -122.6617956161499, 45.53241707548722 ],
+          [ -122.6617956161499, 45.52438983143154 ],
+          [ -122.67072200775145, 45.52438983143154 ]
+        ].map {|c| Terraformer::Coordinate.new c}
+        p_2 = Terraformer::Polygon.new [a, b, c, d, a], hole
+        mp = Terraformer::MultiPolygon.new p_1, p_2
+        mp.must_be_valid_geojson
+      end
+
+    end
+
+  end
+
+  describe 'intersects?' do
+
+    it 'raises on unsupported types' do
+      ->{ PARSED_EXAMPLES[:point].intersects? PARSED_EXAMPLES[:polygon] }.must_raise ArgumentError
+      ->{ PARSED_EXAMPLES[:multi_point].intersects? PARSED_EXAMPLES[:polygon] }.must_raise ArgumentError
+      ->{ PARSED_EXAMPLES[:polygon].intersects? PARSED_EXAMPLES[:point] }.must_raise ArgumentError
+      ->{ PARSED_EXAMPLES[:polygon].intersects? PARSED_EXAMPLES[:multi_point] }.must_raise ArgumentError
+    end
+
+    it 'returns true for intersecting line strings' do
+      a = Terraformer::LineString.new [[0,0], [2,2]]
+      b = Terraformer::LineString.new [[0,2], [2,0]]
+      assert a.intersects? b
+      assert b.intersects? a
+    end
+
+    it 'returns true for intersecting line string and multi line string' do
+      a = Terraformer::LineString.new [[0,0], [2,2]]
+      b = Terraformer::MultiLineString.new [[[0,2], [2,0]], [[3,0], [3,3]]]
+      assert a.intersects? b
+      assert b.intersects? a
+    end
+
+    it 'returns true for intersecting line string and polygon' do
+      a = Terraformer.parse '{
+        "type": "LineString",
+        "coordinates": [
+          [
+            99.99803066253662,
+            -0.001394748687601125
+          ],
+          [
+            99.99983310699463,
+            0
+          ],
+          [
+            100.00056266784668,
+            0.0021886825556223905
+          ]
+        ]
+      }'
+      b = PARSED_EXAMPLES[:circle]
+      assert a.intersects? b
+      assert b.intersects? a
+    end
+
+    it 'returns true for intersecting line string and multi polygon' do
+      a = Terraformer.parse '{
+        "type": "LineString",
+        "coordinates": [
+          [
+            -123.12103271484375,
+            37.67295135774715
+          ],
+          [
+            -122.8656005859375,
+            37.77397129533325
+          ],
+          [
+            -122.22976684570312,
+            37.790251927933284
+          ],
+          [
+            -122.24075317382812,
+            37.95069515957719
+          ]
+        ]
+      }'
+      b = PARSED_EXAMPLES[:sf_county]
+      assert a.intersects? b
+      assert b.intersects? a
+    end
+
+    it 'returns true for intersecting multi line strings' do
+      a = Terraformer.parse '{
+        "type": "MultiLineString",
+        "coordinates": [
+          [
+          [
+            -63.54492187500001,
+            -15.665354182093274
+          ],
+          [
+            -66.95068359374999,
+            -18.22935133838667
+          ],
+          [
+            -65.7421875,
+            -19.746024239625417
+          ],
+          [
+            -63.7646484375,
+            -17.455472579972813
+          ],
+          [
+            -63.03955078125,
+            -19.932041306115526
+          ]
+          ],
+          [
+          [
+            -61.9189453125,
+            -18.47960905583197
+          ],
+          [
+            -62.62207031249999,
+            -16.53089842368168
+          ],
+          [
+            -60.27099609375,
+            -16.467694748288956
+          ],
+          [
+            -60.97412109375,
+            -14.83861155338482
+          ]
+        ]
+        ]
+      }'
+      b = Terraformer.parse '{
+        "type": "LineString",
+        "coordinates": [
+          [
+            [
+              -65.819091796875,
+              -15.876809064146757
+            ],
+            [
+              -63.96240234375,
+              -19.394067895396613
+            ],
+            [
+              -61.292724609375,
+              -17.17228278169307
+            ],
+            [
+              -61.84204101562499,
+              -14.976626651623738
+            ]
+          ],
+          [
+            [
+              -63.29223632812499,
+              -14.615478234145248
+            ],
+            [
+              -62.41333007812499,
+              -19.921712747556207
+            ],
+            [
+              -61.22680664062499,
+              -19.103648251663632
+            ]
+          ]
+        ]
+      }'
+      assert a.intersects? b
+      assert b.intersects? a
+    end
+
+    it 'returns true for intersecting multi line string and polygon' do
+      a = Terraformer.parse '{
+        "type": "MultiLineString",
+        "coordinates": [
+          [
+          [
+            -63.54492187500001,
+            -15.665354182093274
+          ],
+          [
+            -66.95068359374999,
+            -18.22935133838667
+          ],
+          [
+            -65.7421875,
+            -19.746024239625417
+          ],
+          [
+            -63.7646484375,
+            -17.455472579972813
+          ],
+          [
+            -63.03955078125,
+            -19.932041306115526
+          ]
+          ],
+          [
+          [
+            -61.9189453125,
+            -18.47960905583197
+          ],
+          [
+            -62.62207031249999,
+            -16.53089842368168
+          ],
+          [
+            -60.27099609375,
+            -16.467694748288956
+          ],
+          [
+            -60.97412109375,
+            -14.83861155338482
+          ]
+        ]
+        ]
+      }'
+      b = Terraformer.parse '{
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              -63.94042968749999,
+              -16.625665127961494
+            ],
+            [
+              -65.23681640625,
+              -18.26065335675836
+            ],
+            [
+              -64.7314453125,
+              -19.49766416813904
+            ],
+            [
+              -60.732421875,
+              -17.224758206624628
+            ],
+            [
+              -61.61132812500001,
+              -15.64419660086606
+            ],
+            [
+              -63.94042968749999,
+              -16.625665127961494
+            ]
+          ]
+        ]
+      }'
+      assert a.intersects? b
+      assert b.intersects? a
+    end
+
+    it 'returns true for intersecting multi line string and multi polygon' do
+      a = Terraformer.parse '{
+        "type": "MultiLineString",
+        "coordinates": [
+          [
+          [
+            -63.54492187500001,
+            -15.665354182093274
+          ],
+          [
+            -66.95068359374999,
+            -18.22935133838667
+          ],
+          [
+            -65.7421875,
+            -19.746024239625417
+          ],
+          [
+            -63.7646484375,
+            -17.455472579972813
+          ],
+          [
+            -63.03955078125,
+            -19.932041306115526
+          ]
+          ],
+          [
+          [
+            -61.9189453125,
+            -18.47960905583197
+          ],
+          [
+            -62.62207031249999,
+            -16.53089842368168
+          ],
+          [
+            -60.27099609375,
+            -16.467694748288956
+          ],
+          [
+            -60.97412109375,
+            -14.83861155338482
+          ]
+        ]
+        ]
+      }'
+      b = Terraformer.parse '{
+        "type": "MultiPolygon",
+        "coordinates": [[
+          [
+            [
+              -63.94042968749999,
+              -16.625665127961494
+            ],
+            [
+              -65.23681640625,
+              -18.26065335675836
+            ],
+            [
+              -64.7314453125,
+              -19.49766416813904
+            ],
+            [
+              -60.732421875,
+              -17.224758206624628
+            ],
+            [
+              -61.61132812500001,
+              -15.64419660086606
+            ],
+            [
+              -63.94042968749999,
+              -16.625665127961494
+            ]
+          ]],
+          [
+          [
+            [
+              -62.49023437499999,
+              -14.285677300182577
+            ],
+            [
+              -62.314453125,
+              -15.432500881886043
+            ],
+            [
+              -61.3037109375,
+              -15.262988555023204
+            ],
+            [
+              -61.46850585937499,
+              -13.891411092746102
+            ],
+            [
+              -62.49023437499999,
+              -14.285677300182577
+            ]
+          ]
+        ]
+        ]
+      }'
+      assert a.intersects? b
+      assert b.intersects? a
+    end
+
+    it 'returns true for intersecting polygons' do
+      a = Terraformer.parse '{
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              -91.20574951171874,
+              14.777538257344107
+            ],
+            [
+              -91.19613647460938,
+              14.707149905394584
+            ],
+            [
+              -91.13296508789062,
+              14.70449329599549
+            ],
+            [
+              -91.11923217773436,
+              14.76691505925414
+            ],
+            [
+              -91.20574951171874,
+              14.777538257344107
+            ]
+          ]
+        ]
+      }'
+      b = Terraformer.parse '{
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              -91.24008178710938,
+              14.72308888264888
+            ],
+            [
+              -91.22634887695312,
+              14.630095127973206
+            ],
+            [
+              -91.14944458007812,
+              14.639396280953365
+            ],
+            [
+              -91.16867065429688,
+              14.728401616219264
+            ],
+            [
+              -91.24008178710938,
+              14.72308888264888
+            ]
+          ]
+        ]
+      }'
+      assert a.intersects? b
+      assert b.intersects? a
+    end
+
+    it 'returns true for intersecting polygon and multi polygon' do
+      a = Terraformer.parse '{
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              -91.20574951171874,
+              14.777538257344107
+            ],
+            [
+              -91.19613647460938,
+              14.707149905394584
+            ],
+            [
+              -91.13296508789062,
+              14.70449329599549
+            ],
+            [
+              -91.11923217773436,
+              14.76691505925414
+            ],
+            [
+              -91.20574951171874,
+              14.777538257344107
+            ]
+          ]
+        ]
+      }'
+      b = Terraformer.parse '{
+        "type": "MultiPolygon",
+        "coordinates": [
+        [
+          [
+            [
+              -91.24008178710938,
+              14.72308888264888
+            ],
+            [
+              -91.22634887695312,
+              14.630095127973206
+            ],
+            [
+              -91.14944458007812,
+              14.639396280953365
+            ],
+            [
+              -91.16867065429688,
+              14.728401616219264
+            ],
+            [
+              -91.24008178710938,
+              14.72308888264888
+            ]
+          ]
+        ],
+          [
+          [
+            [
+              -91.13845825195312,
+              14.685896125376305
+            ],
+            [
+              -91.14395141601562,
+              14.638067568954588
+            ],
+            [
+              -91.10275268554688,
+              14.644711048453187
+            ],
+            [
+              -91.10824584960938,
+              14.697851631083855
+            ],
+            [
+              -91.13845825195312,
+              14.685896125376305
+            ]
+          ]
+        ]
+          ]
+      }'
+      assert a.intersects? b
+      assert b.intersects? a
+    end
+
+    it 'returns true for intersecting multi polygons' do
+      a = Terraformer.parse '{
+        "type": "MultiPolygon",
+        "coordinates": [[
+          [
+            [
+              -91.20574951171874,
+              14.777538257344107
+            ],
+            [
+              -91.19613647460938,
+              14.707149905394584
+            ],
+            [
+              -91.13296508789062,
+              14.70449329599549
+            ],
+            [
+              -91.11923217773436,
+              14.76691505925414
+            ],
+            [
+              -91.20574951171874,
+              14.777538257344107
+            ]
+          ]
+        ],
+                       [
+          [
+            [
+              -91.29364013671875,
+              14.889050404470884
+            ],
+            [
+              -91.29776000976562,
+              14.753635331540442
+            ],
+            [
+              -91.21810913085938,
+              14.743010965702727
+            ],
+            [
+              -91.21261596679686,
+              14.800110827789874
+            ],
+            [
+              -91.15081787109374,
+              14.862505109695116
+            ],
+            [
+              -91.29364013671875,
+              14.889050404470884
+            ]
+          ]
+        ]]
+      }'
+      b = Terraformer.parse '{
+        "type": "MultiPolygon",
+        "coordinates": [
+        [
+          [
+            [
+              -91.24008178710938,
+              14.72308888264888
+            ],
+            [
+              -91.22634887695312,
+              14.630095127973206
+            ],
+            [
+              -91.14944458007812,
+              14.639396280953365
+            ],
+            [
+              -91.16867065429688,
+              14.728401616219264
+            ],
+            [
+              -91.24008178710938,
+              14.72308888264888
+            ]
+          ]
+        ],
+          [
+          [
+            [
+              -91.13845825195312,
+              14.685896125376305
+            ],
+            [
+              -91.14395141601562,
+              14.638067568954588
+            ],
+            [
+              -91.10275268554688,
+              14.644711048453187
+            ],
+            [
+              -91.10824584960938,
+              14.697851631083855
+            ],
+            [
+              -91.13845825195312,
+              14.685896125376305
+            ]
+          ]
+        ]
+          ]
+      }'
+      assert a.intersects? b
+      assert b.intersects? a
+    end
+
+    it 'returns false for non-intersecting line strings' do
+      a = Terraformer::LineString.new [[0,0],[8,8]]
+      b = Terraformer::LineString.new [[-1,-1],[-8,-8]]
+      refute a.intersects?(b)
+    end
+
+    it 'returns false for non-intersecting polygons' do
+      refute PARSED_EXAMPLES[:circle].intersects? PARSED_EXAMPLES[:sf_county]
+    end
+
+    # todo more false tests
+
+  end
+
+  describe 'contains?' do
+
+    it 'raises on unsupported types' do
+      ->{ PARSED_EXAMPLES[:point].contains? PARSED_EXAMPLES[:polygon] }.must_raise ArgumentError
+      ->{ PARSED_EXAMPLES[:multi_point].contains? PARSED_EXAMPLES[:polygon] }.must_raise ArgumentError
+      ->{ PARSED_EXAMPLES[:line_string].contains? PARSED_EXAMPLES[:polygon] }.must_raise ArgumentError
+      ->{ PARSED_EXAMPLES[:multi_line_string].contains? PARSED_EXAMPLES[:polygon] }.must_raise ArgumentError
+      # todo more?
+    end
+
+    it 'returns true for line strings that contain points' do
+      ls = PARSED_EXAMPLES[:line_string]
+      assert ls.contains? ls.point_at(1)
+      assert ls.contains? [100.5,0.5].to_c.to_point
+    end
+
+    it 'returns true for multi line strings that contain points' do
+      mls = PARSED_EXAMPLES[:multi_line_string]
+      assert mls.contains? mls.line_strings[0].point_at(1)
+    end
+
+    it 'returns true for polygons that contain points' do
+      p = Terraformer.parse '{
+        "type": "Point",
+        "coordinates": [
+          100.56060791015624,
+          0.6783899107121523
+        ]
+      }'
+      assert PARSED_EXAMPLES[:polygon].contains? p
+    end
+
+    it 'returns true for polygons that contain polygons' do
+      pwh = PARSED_EXAMPLES[:polygon_with_holes]
+      p1 = Terraformer::Polygon.new pwh.line_strings[0].coordinates
+      p2 = pwh.holes[0]
+      assert p1.contains? p2
+      refute p2.contains? p1
+    end
+
+    it 'returns true for multi polygons that contain polygons' do
+      p = Terraformer.parse '{
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              102.3101806640625,
+              2.2625953010152453
+            ],
+            [
+              102.3101806640625,
+              2.6632250332728296
+            ],
+            [
+              102.83752441406249,
+              2.6632250332728296
+            ],
+            [
+              102.83752441406249,
+              2.2625953010152453
+            ],
+            [
+              102.3101806640625,
+              2.2625953010152453
+            ]
+          ]
+        ]
+      }'
+      assert PARSED_EXAMPLES[:multi_polygon].contains? p
+    end
+
+    it 'returns false for polygons with holes and point inside hole' do
+      p = Terraformer.parse '{
+        "type": "Point",
+        "coordinates": [
+          100.5194091796875,
+          0.6028636315576017
+        ]
+      }'
+      refute PARSED_EXAMPLES[:polygon_with_holes].contains? p
+    end
+
+    it 'returns false for polygons with holes and polygon inside hole' do
+      p = Terraformer.parse '{
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              100.40130615234375,
+              0.42159653727164975
+            ],
+            [
+              100.40130615234375,
+              0.6509259386918139
+            ],
+            [
+              100.6842041015625,
+              0.6509259386918139
+            ],
+            [
+              100.6842041015625,
+              0.42159653727164975
+            ],
+            [
+              100.40130615234375,
+              0.42159653727164975
+            ]
+          ]
+        ]
+      }'
+      refute PARSED_EXAMPLES[:polygon_with_holes].contains? p
+    end
+
+  end
+
+  describe 'within?' do
+
+    it 'raises on unsupported types' do
+      ->{ PARSED_EXAMPLES[:polygon].within? PARSED_EXAMPLES[:point] }.must_raise ArgumentError
+      ->{ PARSED_EXAMPLES[:polygon].within? PARSED_EXAMPLES[:multi_point] }.must_raise ArgumentError
+      ->{ PARSED_EXAMPLES[:polygon].within? PARSED_EXAMPLES[:line_string] }.must_raise ArgumentError
+      ->{ PARSED_EXAMPLES[:polygon].within? PARSED_EXAMPLES[:multi_line_string] }.must_raise ArgumentError
+      # todo more?
+    end
+
+    it 'returns true for points within line strings' do
+      ls = PARSED_EXAMPLES[:line_string]
+      assert ls.point_at(1).within? ls
+    end
+
+    it 'returns true for points within multi line strings' do
+      mls = PARSED_EXAMPLES[:multi_line_string]
+      assert mls.line_strings[0].point_at(1).within? mls
+    end
+
+    it 'returns true for points within polygons' do
+      p = Terraformer.parse '{
+        "type": "Point",
+        "coordinates": [
+          100.56060791015624,
+          0.6783899107121523
+        ]
+      }'
+      assert p.within? PARSED_EXAMPLES[:polygon]
+    end
+
+    it 'returns true for polygons within polygons' do
+      pwh = PARSED_EXAMPLES[:polygon_with_holes]
+      p1 = Terraformer::Polygon.new pwh.line_strings[0].coordinates
+      p2 = pwh.holes[0]
+      assert p2.within? p1
+      refute p1.within? p2
+    end
+
+    it 'returns true for polygons within multi polygons' do
+      p = Terraformer.parse '{
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              102.3101806640625,
+              2.2625953010152453
+            ],
+            [
+              102.3101806640625,
+              2.6632250332728296
+            ],
+            [
+              102.83752441406249,
+              2.6632250332728296
+            ],
+            [
+              102.83752441406249,
+              2.2625953010152453
+            ],
+            [
+              102.3101806640625,
+              2.2625953010152453
+            ]
+          ]
+        ]
+      }'
+      assert p.within? PARSED_EXAMPLES[:multi_polygon]
+    end
+
+    it 'returns false for points within the hole of polygons with holes' do
+      p = Terraformer.parse '{
+        "type": "Point",
+        "coordinates": [
+          100.5194091796875,
+          0.6028636315576017
+        ]
+      }'
+      refute p.within? PARSED_EXAMPLES[:polygon_with_holes]
+    end
+
+    it 'returns false for polygons within the hole of polygons with holes' do
+      p = Terraformer.parse '{
+        "type": "Polygon",
+        "coordinates": [
+          [
+            [
+              100.40130615234375,
+              0.42159653727164975
+            ],
+            [
+              100.40130615234375,
+              0.6509259386918139
+            ],
+            [
+              100.6842041015625,
+              0.6509259386918139
+            ],
+            [
+              100.6842041015625,
+              0.42159653727164975
+            ],
+            [
+              100.40130615234375,
+              0.42159653727164975
+            ]
+          ]
+        ]
+      }'
+      refute p.within? PARSED_EXAMPLES[:polygon_with_holes]
+    end
+
+  end
+
+  describe Terraformer::Geometry::ClassMethods do
+
+    describe 'edge_intersects_edge?' do
+
+      it 'returns true for edges that intersect' do
+        a = [[0,0], [2,2]].map &:to_c
+        b = [[0,2], [2,0]].map &:to_c
+        Terraformer::Geometry.edge_intersects_edge?(a[0], a[1], b[0], b[1]).must_equal true
+      end
+
+      it 'returns false for edges that do not intersect' do
+        a = [[0,2], [2,2]].map &:to_c
+        b = [[0,0], [2,0]].map &:to_c
+        Terraformer::Geometry.edge_intersects_edge?(a[0], a[1], b[0], b[1]).must_equal false
+      end
+
+    end
+
+    describe 'arrays_intersect_arrays?' do
+
+      it 'returns true for lines that intersect' do
+        a = [[0,0], [2,2]].map &:to_c
+        b = [[0,2], [2,0]].map &:to_c
+        Terraformer::Geometry.arrays_intersect_arrays?(a, b).must_equal true
+      end
+
+      it 'returns false for lines that do not intersect' do
+        a = [[0,2], [2,2]].map &:to_c
+        b = [[0,0], [2,0]].map &:to_c
+        Terraformer::Geometry.arrays_intersect_arrays?(a, b).must_equal false
+      end
+
+    end
+
+    describe 'line_cotains_point?' do
+
+      it 'returns true for points on the line' do
+        assert Terraformer::Geometry.line_contains_point? [[0,0].to_c, [4,4].to_c], [2,2].to_c
+      end
+
+      it 'returns false for points that are not on the line' do
+        refute Terraformer::Geometry.line_contains_point? [[0,0].to_c, [4,4].to_c], [0,2].to_c
+      end
+
+      it 'returns true for points on the ends of the line' do
+        assert Terraformer::Geometry.line_contains_point? [[0,0].to_c, [4,4].to_c], [0,0].to_c
+        assert Terraformer::Geometry.line_contains_point? [[0,0].to_c, [4,4].to_c], [4,4].to_c
+      end
+
+    end
+
+  end
+
+end