geometry 6.4 → 6.6

data/test/geometry/line.rb

@@ -134,6 +134,29 @@ describe Geometry::PointSlopeLine do
 	line2.must_equal subject
 	line3.wont_equal subject
     end
+
+    it 'must know how to be horizontal' do
+	Geometry::PointSlopeLine.new([1,2],0).horizontal?.must_equal true
+	Geometry::PointSlopeLine.new([1,2],1).horizontal?.must_equal false
+    end
+
+    it 'must know how to be vertical' do
+	Geometry::PointSlopeLine.new([1,2], Float::INFINITY).vertical?.must_equal true
+	Geometry::PointSlopeLine.new([1,2], -Float::INFINITY).vertical?.must_equal true
+	Geometry::PointSlopeLine.new([1,2],1).vertical?.must_equal false
+    end
+
+    it 'must have an x-intercept' do
+	subject.intercept(:x).must_equal 1
+    end
+
+    it 'must not have an x-intercept for horizontal lines' do
+	Geometry::PointSlopeLine.new([1,2], 0).intercept(:x).must_equal nil
+    end
+
+    it 'must have a y-intercept' do
+	subject.intercept.must_equal(-1)
+    end
 end
 
 describe Geometry::SlopeInterceptLine do
@@ -163,6 +186,29 @@ describe Geometry::SlopeInterceptLine do
 	line2.must_equal subject
 	line3.wont_equal subject
     end
+
+    it 'must know how to be horizontal' do
+	Geometry::SlopeInterceptLine.new(0, 2).horizontal?.must_equal true
+	Geometry::SlopeInterceptLine.new(1, 2).horizontal?.must_equal false
+    end
+
+    it 'must know how to be vertical' do
+	Geometry::SlopeInterceptLine.new(Float::INFINITY, 2).vertical?.must_equal true
+	Geometry::SlopeInterceptLine.new(-Float::INFINITY, 2).vertical?.must_equal true
+	Geometry::SlopeInterceptLine.new(1, 2).vertical?.must_equal false
+    end
+
+    it 'must have an x-intercept' do
+	subject.intercept(:x).must_equal(-2/3)
+    end
+
+    it 'must not have an x-intercept for horizontal lines' do
+	Geometry::SlopeInterceptLine.new(0, 2).intercept(:x).must_equal nil
+    end
+
+    it 'must have a y-intercept' do
+	subject.intercept.must_equal 2
+    end
 end
 
 describe Geometry::TwoPointLine do
@@ -192,4 +238,31 @@ describe Geometry::TwoPointLine do
 	line2.must_equal subject
 	line3.wont_equal subject
     end
+
+    it 'must know how to be horizontal' do
+	Geometry::TwoPointLine.new([1,2],[2,2]).horizontal?.must_equal true
+	Geometry::TwoPointLine.new([1,2],[3,4]).horizontal?.must_equal false
+    end
+
+    it 'must know how to be vertical' do
+	Geometry::TwoPointLine.new([1,2], [1,3]).vertical?.must_equal true
+	Geometry::TwoPointLine.new([1,2], [1,-3]).vertical?.must_equal true
+	Geometry::TwoPointLine.new([1,2],[3,4]).vertical?.must_equal false
+    end
+
+    it 'must have an x-intercept' do
+	subject.intercept(:x).must_equal(-1)
+    end
+
+    it 'must not have an x-intercept for horizontal lines' do
+	Geometry::TwoPointLine.new([1,2],[2,2]).intercept(:x).must_equal nil
+    end
+
+    it 'must have an x-intercept for vertical lines' do
+	Geometry::TwoPointLine.new([1,2], [1,3]).intercept(:x).must_equal 1
+    end
+
+    it 'must have a y-intercept' do
+	subject.intercept.must_equal 1
+    end
 end

data/test/geometry/path.rb

@@ -63,4 +63,20 @@ describe Geometry::Path do
 	    path.elements[0].last.must_equal path.elements[1].first
 	end
     end
+
+    describe 'attributes' do
+	let(:unit_square) { Geometry::Path.new [0,0], [1,0], [1,1], [0,1] }
+
+	it 'must know the max' do
+	    unit_square.max.must_equal Point[1,1]
+	end
+
+	it 'must know the min' do
+	    unit_square.min.must_equal Point[0,0]
+	end
+
+	it 'must know the min and the max' do
+	    unit_square.minmax.must_equal [Point[0,0], Point[1,1]]
+	end
+    end
 end

data/test/geometry/point.rb

@@ -2,6 +2,7 @@ require 'minitest/autorun'
 require 'geometry/point'
 
 describe Geometry::Point do
+    PointIso = Geometry::PointIso
     PointOne = Geometry::PointOne
     PointZero = Geometry::PointZero
 
@@ -14,6 +15,15 @@ describe Geometry::Point do
 	    Point.one(3).must_equal Point[1,1,1]
 	end
 
+	it 'must generate a PointIso' do
+	    Point.iso(3).must_be_kind_of(PointIso)
+	    Point.iso(3).value.must_equal 3
+	end
+
+	it 'must generate a Point filled with a given value' do
+	    Point.iso(3, 2).must_equal Point[3,3]
+	end
+
 	it "must generate a PointZero" do
 	    Point.zero.must_be_instance_of(PointZero)
 	end
@@ -114,7 +124,24 @@ describe Geometry::Point do
 	Point[1,2].dup.must_equal Point[1,2]
     end
 
-    describe 'minmax' do
+    it 'must pop' do
+	Point[1,2,3,4].pop.must_equal Point[4]
+	Point[1,2,3,4].pop(2).must_equal Point[3,4]
+    end
+
+    it 'must push' do
+	Point[1,2].push(3,4).must_equal Point[1,2,3,4]
+    end
+
+    it 'must shift' do
+	Point[1,2,3,4].shift.must_equal Point[1]
+    end
+
+    it 'must unshift' do
+	Point[2,3,4].unshift(1).must_equal Point[1,2,3,4]
+    end
+
+    describe 'minimum' do
 	it 'must have a minimum' do
 	    Point[1,2].min.must_equal 1
 	end
@@ -132,6 +159,20 @@ describe Geometry::Point do
 	    Point[1,3].min(4,2).must_equal Point[1,2]
 	end
 
+	it 'must minimum with a PointIso' do
+	    Point[-5,-5,5].min(PointIso.new(-5/2)).must_equal Point[-5,-5,-5/2]
+	end
+
+	it 'must minimum with a PointOne' do
+	    Point[-5,-5,5].min(Point.one).must_equal Point[-5,-5,1]
+	end
+
+	it 'must minimum with a PointZero' do
+	    Point[-5,-5,5].min(Point.zero).must_equal Point[-5,-5,0]
+	end
+    end
+
+    describe 'maximum' do
 	it 'must have a maximum' do
 	    Point[1,2].max.must_equal 2
 	end
@@ -149,6 +190,20 @@ describe Geometry::Point do
 	    Point[1,3].max(4,2).must_equal Point[4,3]
 	end
 
+	it 'must maximum with a PointIso' do
+	    Point[-5,-5,5].max(PointIso.new(-5/2)).must_equal Point[-5/2, -5/2, 5]
+	end
+
+	it 'must maximum with a PointOne' do
+	    Point[-5,-5,5].max(Point.one).must_equal Point[1, 1, 5]
+	end
+
+	it 'must maximum with a PointZero' do
+	    Point[-5,-5,5].max(Point.zero).must_equal Point[0, 0, 5]
+	end
+    end
+
+    describe 'minmax' do
 	it 'must have a minmax' do
 	    Point[1,2].minmax.must_equal [1,2]
 	end
@@ -161,9 +216,21 @@ describe Geometry::Point do
 	    Point[1,3].minmax([4,2]).must_equal [Point[1,2], Point[4,3]]
 	end
 
-	it 'must maximum with multiple arguments' do
+	it 'must minmax with multiple arguments' do
 	    Point[1,3].minmax(4,2).must_equal [Point[1,2], Point[4,3]]
 	end
+
+	it 'must minmax with a PointIso' do
+	    Point[-5,-5,5].minmax(PointIso.new(-5/2)).must_equal [Point[-5,-5,-5/2], Point[-5/2, -5/2, 5]]
+	end
+
+	it 'must minmax with a PointOne' do
+	    Point[-5,-5,5].minmax(Point.one).must_equal [Point[-5,-5,1], Point[1, 1, 5]]
+	end
+
+	it 'must minmax with a PointZero' do
+	    Point[-5,-5,5].minmax(Point.zero).must_equal [Point[-5,-5,0], Point[0, 0, 5]]
+	end
     end
 
     describe "arithmetic" do
@@ -254,6 +321,15 @@ describe Geometry::Point do
 	end
     end
 
+    describe 'attributes' do
+	it 'must have a quadrant' do
+	    Point[1,1].quadrant.must_equal 1
+	    Point[-1,1].quadrant.must_equal 2
+	    Point[-1,-1].quadrant.must_equal 3
+	    Point[1,-1].quadrant.must_equal 4
+	end
+    end
+
     describe "coercion" do
 	subject { Point[1,2] }
 

data/test/geometry/point_iso.rb

@@ -2,9 +2,19 @@ require 'minitest/autorun'
 require 'geometry/point_iso'
 
 describe Geometry::PointIso do
-    let(:value) { 5 }
+    let(:iso_value) { 5 }
     subject { Geometry::PointIso.new(5) }
 
+    it 'must pop' do
+	subject.pop.must_equal Point[5]
+	subject.pop(2).must_equal Point[5, 5]
+    end
+
+    it 'must shift' do
+	subject.shift.must_equal Point[5]
+	subject.shift(2).must_equal Point[5, 5]
+    end
+
     describe 'minmax' do
 	it 'must have a minimum' do
 	    subject.min.must_equal 5
@@ -73,30 +83,30 @@ describe Geometry::PointIso do
 	end
 
 	it 'must have +@' do
-	    (+subject).must_be :eql?, value
+	    (+subject).must_be :eql?, iso_value
 	    (+subject).must_be_instance_of(Geometry::PointIso)
 	end
 
 	it 'must have unary negation' do
-	    (-subject).must_be :eql?, -value
+	    (-subject).must_be :eql?, -iso_value
 	    (-subject).must_be_instance_of(Geometry::PointIso)
 	end
 
 	describe 'Accessors' do
 	    it 'must return 1 for array access' do
-		subject[3].must_equal value
+		subject[3].must_equal iso_value
 	    end
 
 	    it 'must return 1 for named element access' do
-		subject.x.must_equal value
-		subject.y.must_equal value
-		subject.z.must_equal value
+		subject.x.must_equal iso_value
+		subject.y.must_equal iso_value
+		subject.z.must_equal iso_value
 	    end
 	end
 
 	it 'must add a number' do
-	    (subject + 3).must_equal (value + 3)
-	    (3 + subject).must_equal (3 + value)
+	    (subject + 3).must_equal (iso_value + 3)
+	    (3 + subject).must_equal (3 + iso_value)
 	end
 
 	it 'return a Point when adding two Points' do
@@ -105,24 +115,24 @@ describe Geometry::PointIso do
 	end
 
 	it 'must return an Array when adding an array' do
-	    (subject + [5,6]).must_equal [value+5, value+6]
+	    (subject + [5,6]).must_equal [iso_value+5, iso_value+6]
 #	    ([5,6] + subject).must_equal [10, 11]
 	end
 
 	it 'must return a Point when adding a Size' do
 	    (subject + Size[5,6]).must_be_instance_of(Point)
-	    (subject + Size[5,6]).must_equal Point[value+5, value+6]
+	    (subject + Size[5,6]).must_equal Point[iso_value+5, iso_value+6]
 	end
 
 	describe 'when subtracting' do
 	    it 'must subtract a number' do
-		(subject - 3).must_equal (value - 3)
-		(3 - subject).must_equal -2
+		(subject - 3).must_equal (iso_value - 3)
+		(3 - subject).must_equal(-2)
 	    end
 
 	    it 'return a Point when subtracting two Points' do
-		(subject - right).must_equal Point[value - right.x, value - right.y]
-		(left - subject).must_equal Point[left.x - value, left.y - value]
+		(subject - right).must_equal Point[iso_value - right.x, iso_value - right.y]
+		(left - subject).must_equal Point[left.x - iso_value, left.y - iso_value]
 	    end
 
 	    it 'must return a Point when subtracting an array' do
@@ -221,15 +231,15 @@ describe Geometry::PointIso do
 	end
 
 	it 'must be equal to a Point of subjects' do
-	    subject.must_be :==, Point[value, value]
-	    subject.must_be :eql?, Point[value, value]
-	    subject.must_be :===, Point[value, value]
-	    Point[value, value].must_equal subject
-	    subject.must_equal Point[value, value]
+	    subject.must_be :==, Point[iso_value, iso_value]
+	    subject.must_be :eql?, Point[iso_value, iso_value]
+	    subject.must_be :===, Point[iso_value, iso_value]
+	    Point[iso_value, iso_value].must_equal subject
+	    subject.must_equal Point[iso_value, iso_value]
 	end
 
 	it 'must be equal to an Vector of the same value' do
-	    subject.must_be :eql?, Vector[value, value]
+	    subject.must_be :eql?, Vector[iso_value, iso_value]
 	    Vector[5, 5].must_equal subject
 	end
 

data/test/geometry/point_one.rb

@@ -5,6 +5,16 @@ describe Geometry::PointOne do
     subject { Geometry::PointOne.new }
     let(:one) { Geometry::PointOne.new }
 
+    it 'must pop' do
+	subject.pop.must_equal Point[1]
+	subject.pop(2).must_equal Point[1, 1]
+    end
+
+    it 'must shift' do
+	subject.shift.must_equal Point[1]
+	subject.shift(2).must_equal Point[1, 1]
+    end
+
     describe 'minmax' do
 	it 'must have a minimum' do
 	    subject.min.must_equal 1
@@ -116,7 +126,7 @@ describe Geometry::PointOne do
 
 	describe 'when subtracting' do
 	    it 'must subtract a number' do
-		(one - 3).must_equal -2
+		(one - 3).must_equal(-2)
 		(3 - one).must_equal 2
 	    end
 

data/test/geometry/point_zero.rb

@@ -5,55 +5,65 @@ describe Geometry::PointZero do
     subject { Geometry::PointZero.new }
     let(:zero) { Geometry::PointZero.new }
 
-describe 'minmax' do
-    it 'must have a minimum' do
-	subject.min.must_equal 0
+    it 'must pop' do
+	subject.pop.must_equal Point[0]
+	subject.pop(2).must_equal Point[0, 0]
     end
 
-    it 'must minimum with another Point' do
-	subject.min(Point[-1,7]).must_equal Point[-1,0]
+    it 'must shift' do
+	subject.shift.must_equal Point[0]
+	subject.shift(2).must_equal Point[0, 0]
     end
 
-    it 'must minimum with an Array' do
-	subject.min([-1,7]).must_equal Point[-1,0]
-    end
+    describe 'minmax' do
+	it 'must have a minimum' do
+	    subject.min.must_equal 0
+	end
 
-    it 'must minimum with a multiple arguments' do
-	subject.min(-1,7).must_equal Point[-1,0]
-    end
+	it 'must minimum with another Point' do
+	    subject.min(Point[-1,7]).must_equal Point[-1,0]
+	end
 
-    it 'must have a maximum' do
-	subject.max.must_equal 0
-    end
+	it 'must minimum with an Array' do
+	    subject.min([-1,7]).must_equal Point[-1,0]
+	end
 
-    it 'must maximum with another Point' do
-	subject.max(Point[7,-1]).must_equal Point[7,0]
-    end
+	it 'must minimum with a multiple arguments' do
+	    subject.min(-1,7).must_equal Point[-1,0]
+	end
 
-    it 'must maximum with an Array' do
-	subject.max([7,-1]).must_equal Point[7,0]
-    end
+	it 'must have a maximum' do
+	    subject.max.must_equal 0
+	end
 
-    it 'must maximum with multiple arguments' do
-	subject.max(7,-1).must_equal Point[7,0]
-    end
+	it 'must maximum with another Point' do
+	    subject.max(Point[7,-1]).must_equal Point[7,0]
+	end
 
-    it 'must have a minmax' do
-	subject.minmax.must_equal [0, 0]
-    end
+	it 'must maximum with an Array' do
+	    subject.max([7,-1]).must_equal Point[7,0]
+	end
 
-    it 'must minmax with another Point' do
-	subject.minmax(Point[7,-1]).must_equal [Point[0,-1], Point[7,0]]
-    end
+	it 'must maximum with multiple arguments' do
+	    subject.max(7,-1).must_equal Point[7,0]
+	end
 
-    it 'must minmax with an Array' do
-	subject.minmax([7,-1]).must_equal [Point[0,-1], Point[7,0]]
-    end
+	it 'must have a minmax' do
+	    subject.minmax.must_equal [0, 0]
+	end
 
-    it 'must maximum with multiple arguments' do
-	subject.minmax(7,-1).must_equal [Point[0,-1], Point[7,0]]
+	it 'must minmax with another Point' do
+	    subject.minmax(Point[7,-1]).must_equal [Point[0,-1], Point[7,0]]
+	end
+
+	it 'must minmax with an Array' do
+	    subject.minmax([7,-1]).must_equal [Point[0,-1], Point[7,0]]
+	end
+
+	it 'must maximum with multiple arguments' do
+	    subject.minmax(7,-1).must_equal [Point[0,-1], Point[7,0]]
+	end
     end
-end
 
     describe "arithmetic" do
 	let(:left) { Point[1,2] }
@@ -117,7 +127,7 @@ end
 	
 	describe "when subtracting" do
 	    it "must return a number" do
-		(zero - 3).must_equal -3
+		(zero - 3).must_equal(-3)
 		(3 - zero).must_equal 3
 	    end
 

data/test/geometry/polygon.rb

@@ -118,7 +118,7 @@ describe Geometry::Polygon do
 
     describe "spaceship" do
 	it "with a Point" do
-	    (unit_square <=> Point[2,0]).must_equal -1
+	    (unit_square <=> Point[2,0]).must_equal(-1)
 	    (unit_square <=> Point[1,0]).must_equal 0
 	    (unit_square <=> Point[0.5,0.5]).must_equal 1
 	end

data/test/geometry/rectangle.rb

@@ -133,10 +133,11 @@ describe Geometry::Rectangle do
 	    edges.each {|edge| assert_kind_of(Geometry::Edge, edge)}
 	end
 
-	it "have a points property that returns 4 points" do
+	it "have a points property that returns 4 points in clockwise order starting from the lower-left" do
 	    points = rectangle.points
 	    assert_equal(4, points.size)
 	    points.each {|point| assert_kind_of(Geometry::Point, point)}
+	    points.must_equal [Point[1,2], Point[1,4], Point[3,4], Point[3,2]]
 	end
 
 	it "must have a bounds property that returns a Rectangle" do
@@ -154,5 +155,9 @@ describe Geometry::Rectangle do
 	it "must have a min property that returns the lower left corner of the bounding rectangle" do
 	    subject.min.must_equal Point[1,2]
 	end
+
+	it 'must have a path property that returns a closed Path' do
+	    rectangle.path.must_equal Geometry::Path.new([1,2], [1,4], [3,4], [3,2], [1,2])
+	end
     end
 end

data/test/geometry/rotation.rb

@@ -13,7 +13,7 @@ describe Geometry::Rotation do
 	    rotation.angle.must_equal Math::PI/2
 	    rotation.x.x.must_be_close_to 0
 	    rotation.x.y.must_be_close_to 1
-	    rotation.y.x.must_be_close_to -1
+	    rotation.y.x.must_be_close_to(-1)
 	    rotation.y.y.must_be_close_to 0
 	end
 

data/test/geometry/size_one.rb

@@ -37,7 +37,7 @@ describe Geometry::SizeOne do
 
 	describe 'when subtracting' do
 	    it 'must subtract a number' do
-		(one - 3).must_equal -2
+		(one - 3).must_equal(-2)
 		(3 - one).must_equal 2
 	    end
 

data/test/geometry/size_zero.rb

@@ -39,7 +39,7 @@ describe Geometry::SizeZero do
 	
 	describe "when subtracting" do
 	    it "must return a number" do
-		(zero - 3).must_equal -3
+		(zero - 3).must_equal(-3)
 		(3 - zero).must_equal 3
 	    end
 

data/test/geometry/square.rb

@@ -9,7 +9,7 @@ describe Geometry::Square do
 	    square = Square.new from:[1,2], to:[3,4]
 	    square.must_be_kind_of Geometry::Square
 	end
-	
+
 	it "must reorder swapped points when constructed from two Points" do
 	    square = Geometry::Square.new from:[3,4], to:[1,2]
 	    square.must_be_kind_of Geometry::Square
@@ -57,7 +57,7 @@ describe Geometry::Square do
 	    -> { Square.new size:[1,2] }.must_raise Geometry::NotSquareError
 	end
     end
-    
+
     describe "properties" do
 	subject { Square.new from:[2,3], to:[3,4] }
 
@@ -66,7 +66,7 @@ describe Geometry::Square do
 	end
 
 	it 'must have edges' do
-	    subject.edges.must_equal [Edge([2,3], [3,3]), Edge.new([3,3], [3,4]), Edge.new([3,4], [2,4]), Edge.new([2,4], [2,3])]
+	    subject.edges.must_equal [Edge([2,3], [2,4]), Edge.new([2,4], [3,4]), Edge.new([3,4], [3,3]), Edge.new([3,3], [2,3])]
 	end
 
 	it "must have an origin accessor" do
@@ -85,8 +85,13 @@ describe Geometry::Square do
 	    subject.min.must_equal Point[2, 3]
 	end
 
-	it 'must have points' do
-	    subject.points.must_equal [Point[2,3], Point[3,3], Point[3,4], Point[2,4]]
+	it 'have a points property that returns 4 points in clockwise order starting from the lower-left' do
+	    subject.points.must_equal [Point[2,3], Point[2,4], Point[3,4], Point[3,3]]
+	end
+
+	it 'must have a path property that returns a closed Path' do
+	    square = Geometry::Square.new origin:[0,0], size:5
+	    square.path.must_equal Geometry::Path.new([0,0], [0,5], [5,5], [5,0], [0,0])
 	end
     end
 end
@@ -102,13 +107,13 @@ describe Geometry::CenteredSquare do
 
     describe "properties" do
 	let(:square) { Geometry::CenteredSquare.new [2,3], 4 }
-	
+
 	it "must have a center property" do
 	    square.center.must_equal Point[2,3]
 	end
 
-	it "must have a points property" do
-	    square.points.must_equal [Point[0,1], Point[4,1], Point[4,5], Point[0,5]]
+	it 'have a points property that returns 4 points in clockwise order starting from the lower-left' do
+	    square.points.must_equal [Point[0,1], Point[0,5], Point[4,5], Point[4,1]]
 	end
 
 	it "must have a height property" do
@@ -149,8 +154,8 @@ describe Geometry::SizedSquare do
 	    square.center.must_equal Point[4,5]
 	end
 
-	it "must have a points property" do
-	    square.points.must_equal [Point[2,3], Point[6,3], Point[6,7], Point[2,7]]
+	it 'have a points property that returns 4 points in clockwise order starting from the lower-left' do
+	    square.points.must_equal [Point[2,3], Point[2,7], Point[6,7], Point[6,3]]
 	end
 
 	it "must have a height property" do

data/test/geometry/transformation.rb

@@ -78,12 +78,26 @@ describe Geometry::Transformation do
 		rotation.angle.must_equal Math::PI/2
 		rotation.x.x.must_be_close_to 0
 		rotation.x.y.must_be_close_to 1
-		rotation.y.x.must_be_close_to -1
+		rotation.y.x.must_be_close_to(-1)
 		rotation.y.y.must_be_close_to 0
 	    end
 	end
     end
 
+    describe 'convenience constructors' do
+	it 'must create a translation from coordinates' do
+	    Geometry.translation(1, 2, 3).translation.must_equal Point[1,2,3]
+	end
+
+	it 'must create a translation from an Array' do
+	    Geometry.translation([1, 2, 3]).translation.must_equal Point[1,2,3]
+	end
+
+	it 'must create a translation from a Point' do
+	    Geometry.translation(Point[1, 2, 3]).translation.must_equal Point[1,2,3]
+	end
+    end
+
     it 'must translate with a Point' do
 	Transformation.new(translate:[1,2]).translate(Point[3,4]).translation.must_equal Point[4,6]
     end

data/test/geometry/vector.rb

@@ -15,7 +15,7 @@ describe Vector do
 	end
 	
 	it "must cross product" do
-	    left.cross(right).must_equal -2
+	    left.cross(right).must_equal(-2)
 	    Vector[1,2,3].cross(Vector[3,4,5]).must_equal Vector[-2, 4, -2]
 	    (Vector[1,2,3] ** Vector[3,4,5]).must_equal Vector[-2, 4, -2]
 	end