geometry 6.5 → 6.6

data/lib/geometry/square.rb

@@ -16,10 +16,6 @@ The {Square} class cluster is like the {Rectangle} class cluster, but not longer
     class Square
 	include ClusterFactory
 
-	# @!attribute origin
-	#   @return [Point]  The {Square}'s origin
-	attr_reader :origin
-
 	# @!attribute points
 	#   @return [Array<Point>]  the corner {Point}s of the {Square} in counter-clockwise order
 	attr_reader :points
@@ -101,15 +97,16 @@ The {Square} class cluster is like the {Rectangle} class cluster, but not longer
 	    [self.min, self.max]
 	end
 
-	# @attribute [r] origin
-	# @return [Point] The lower left corner
+	# @!attribute origin
+	#   @return [Point]  The {Square}'s origin (lower-left corner)
 	def origin
 	    @points.first
 	end
 
+	# @return [Array<Point>]    The {Square}'s four points (clockwise)
 	def points
 	    p0, p1 = *@points
-	    [p0, Point[p1.x, p0.y], p1, Point[p0.x, p1.y]]
+	    [p0, Point[p0.x, p1.y], p1, Point[p1.x, p0.y]]
 	end
 
 	def height
@@ -122,6 +119,11 @@ The {Square} class cluster is like the {Rectangle} class cluster, but not longer
 	    max.x - min.x
 	end
 # @endgroup
+
+	# @return [Path]    A closed {Path} that traces the boundary of the {Square} clockwise, starting from the lower-left
+	def path
+	    Path.new(*self.points, self.points.first)
+	end
     end
 
     # A {Square} created with a center point and a size
@@ -166,7 +168,7 @@ The {Square} class cluster is like the {Rectangle} class cluster, but not longer
 	end
 
 	# @attribute [r] points
-	# @return [Array<Point>]    The {Square}'s four points (counterclockwise)
+	# @return [Array<Point>]    The {Square}'s four points (clockwise)
 	def points
 	    half_size = @size/2
 	    minx = @center.x - half_size
@@ -174,7 +176,7 @@ The {Square} class cluster is like the {Rectangle} class cluster, but not longer
 	    miny = @center.y - half_size
 	    maxy = @center.y + half_size
 
-	    [Point[minx,miny], Point[maxx, miny], Point[maxx, maxy], Point[minx,maxy]]
+	    [Point[minx,miny], Point[minx, maxy], Point[maxx, maxy], Point[maxx,miny]]
 	end
 
 	def height
@@ -224,14 +226,14 @@ The {Square} class cluster is like the {Rectangle} class cluster, but not longer
 	end
 
 	# @attribute [r] points
-	# @return [Array<Point>]    The {Square}'s four points (counterclockwise)
+	# @return [Array<Point>]    The {Square}'s four points (clockwise)
 	def points
 	    minx = origin.x
 	    maxx = origin.x + size
 	    miny = origin.y
 	    maxy = origin.y + size
 
-	    [origin, Point[maxx, miny], Point[maxx, maxy], Point[minx,maxy]]
+	    [origin, Point[minx, maxy], Point[maxx, maxy], Point[maxx,miny]]
 	end
 
 	# @return [Number]  The size of the {Square} along the y-axis

data/lib/geometry/transformation/composition.rb

@@ -32,7 +32,7 @@ module Geometry
 # @endgroup
 
 	    def transform(point)
-		transformations.reverse.reduce(point) {|point, transformation| transformation.transform(point) }
+		transformations.reverse.reduce(point) {|_point, transformation| transformation.transform(_point) }
 	    end
 	end
     end

data/lib/geometry/triangle.rb

@@ -30,7 +30,7 @@ An isoscoles right {Triangle} created with an origin and leg length
 	#   @param [Number] height  The length of the {Triangle}'s vertical leg
 	def self.new(*args)
 	     if args.size == 3
-		ScaleneTriangle.new *args
+		ScaleneTriangle.new(*args)
 	     elsif args.size == 2
 		RightTriangle.new args[0], args[1], args[1]
 	     end

data/test/geometry/arc.rb

@@ -23,3 +23,101 @@ describe Geometry::Arc do
 	end
     end
 end
+
+describe Geometry::ThreePointArc do
+    it 'must have an ending angle' do
+	arc = Geometry::ThreePointArc.new([0,0], [1,0], [0,1])
+	arc.end_angle.must_equal Math::PI/2
+    end
+
+    it 'must have a radius' do
+	arc = Geometry::ThreePointArc.new([0,0], [1,0], [0,1])
+	arc.radius.must_equal 1
+    end
+
+    it 'must have an starting angle' do
+	arc = Geometry::ThreePointArc.new([0,0], [1,0], [0,1])
+	arc.start_angle.must_equal 0
+    end
+
+    describe 'max' do
+	# Cosine and sine of a 22.5 degree angle
+	let(:cos) { 0.9239556995 }
+	let(:sin) { 0.3824994973 }
+	let(:radius) { 1.0000000000366434 }
+
+	it 'must handle an Arc entirely in quadrant 1' do
+	    arc = Geometry::ThreePointArc.new([0,0], [cos,sin], [sin,cos])
+	    arc.max.must_equal Point[cos,cos]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 1 to quadrant 2' do
+	    arc = Geometry::ThreePointArc.new([0,0], [cos,sin], [-cos,sin])
+	    arc.max.must_equal Point[cos,radius]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 4 to quadrant 1' do
+	    arc = Geometry::ThreePointArc.new([0,0], [sin,-cos], [sin,cos])
+	    arc.max.must_equal Point[radius,cos]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 3 to quadrant 2' do
+	    arc = Geometry::ThreePointArc.new([0,0], [-cos,-sin], [-cos,sin])
+	    arc.max.must_equal Point[radius,radius]
+	end
+    end
+
+    describe 'min' do
+	# Cosine and sine of a 22.5 degree angle
+	let(:cos) { 0.9239556995 }
+	let(:sin) { 0.3824994973 }
+	let(:radius) { 1.0000000000366434 }
+
+	it 'must handle an Arc entirely in quadrant 1' do
+	    arc = Geometry::ThreePointArc.new([0,0], [cos,sin], [sin,cos])
+	    arc.min.must_equal Point[sin,sin]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 1 to quadrant 2' do
+	    arc = Geometry::ThreePointArc.new([0,0], [cos,sin], [-cos,sin])
+	    arc.min.must_equal Point[-cos,sin]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 4 to quadrant 1' do
+	    arc = Geometry::ThreePointArc.new([0,0], [sin,-cos], [sin,cos])
+	    arc.min.must_equal Point[sin,-cos]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 3 to quadrant 2' do
+	    arc = Geometry::ThreePointArc.new([0,0], [-cos,-sin], [-cos,sin])
+	    arc.min.must_equal Point[-cos,-radius]
+	end
+    end
+
+    describe 'minmax' do
+	# Cosine and sine of a 22.5 degree angle
+	let(:cos) { 0.9239556995 }
+	let(:sin) { 0.3824994973 }
+	let(:radius) { 1.0000000000366434 }
+
+	it 'must handle an Arc entirely in quadrant 1' do
+	    arc = Geometry::ThreePointArc.new([0,0], [cos,sin], [sin,cos])
+	    arc.minmax.must_equal [Point[sin,sin], Point[cos,cos]]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 1 to quadrant 2' do
+	    arc = Geometry::ThreePointArc.new([0,0], [cos,sin], [-cos,sin])
+	    arc.minmax.must_equal [Point[-cos,sin], Point[cos,radius]]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 4 to quadrant 1' do
+	    arc = Geometry::ThreePointArc.new([0,0], [sin,-cos], [sin,cos])
+	    arc.minmax.must_equal [Point[sin,-cos], Point[radius,cos]]
+	end
+
+	it 'must handle a counterclockwise Arc from quadrant 3 to quadrant 2' do
+	    arc = Geometry::ThreePointArc.new([0,0], [-cos,-sin], [-cos,sin])
+	    arc.minmax.must_equal [Point[-cos,-radius], Point[radius,radius]]
+	end
+    end
+end

data/test/geometry/circle.rb

@@ -108,17 +108,17 @@ describe Geometry::Circle do
 	let(:circle) { Circle.new :diameter => Rational(5,3) }
 
 	it 'must have the correct min values' do
-	    circle.min.must_equal Point[-5/6, -5/6]
+	    circle.min.must_equal Point[-5.to_r/6, -5.to_r/6]
 	    circle.min.must_be_instance_of Geometry::PointIso
 	end
 
 	it 'must have the correct max values' do
-	    circle.max.must_equal Point[5/6, 5/6]
+	    circle.max.must_equal Point[5.to_r/6, 5.to_r/6]
 	    circle.max.must_be_instance_of Geometry::PointIso
 	end
 
 	it 'must have the correct minmax values' do
-	    circle.minmax.must_equal [Point[-5/6, -5/6], Point[5/6,5/6]]
+	    circle.minmax.must_equal [Point[-5.to_r/6, -5.to_r/6], Point[5.to_r/6,5.to_r/6]]
 	end
     end
 

data/test/geometry/edge.rb

@@ -75,11 +75,25 @@ describe Geometry::Edge do
 	subject.to_a.must_equal original.reverse
     end
 
+    describe 'attributes' do
+	it 'must have a maximum' do
+	    Edge([0,0], [1,1]).max.must_equal Point[1,1]
+	end
+
+	it 'must have a minimum' do
+	    Edge([0,0], [1,1]).min.must_equal Point[0,0]
+	end
+
+	it 'must have a minmax' do
+	    Edge([0,0], [1,1]).minmax.must_equal [Point[0,0], Point[1,1]]
+	end
+    end
+
     describe "spaceship" do
 	it "ascending with a Point" do
 	    edge = Edge.new [0,0], [1,1]
 	    (edge <=> Point[0,0]).must_equal 0
-	    (edge <=> Point[1,0]).must_equal -1
+	    (edge <=> Point[1,0]).must_equal(-1)
 	    (edge <=> Point[0,1]).must_equal 1
 	    (edge <=> Point[2,2]).must_equal nil
 	end
@@ -88,7 +102,7 @@ describe Geometry::Edge do
 	    edge = Edge.new [1,1], [0,0]
 	    (edge <=> Point[0,0]).must_equal 0
 	    (edge <=> Point[1,0]).must_equal 1
-	    (edge <=> Point[0,1]).must_equal -1
+	    (edge <=> Point[0,1]).must_equal(-1)
 	    (edge <=> Point[2,2]).must_equal nil
 	end
     end

data/test/geometry/line.rb

@@ -155,7 +155,7 @@ describe Geometry::PointSlopeLine do
     end
 
     it 'must have a y-intercept' do
-	subject.intercept.must_equal -1
+	subject.intercept.must_equal(-1)
     end
 end
 
@@ -199,7 +199,7 @@ describe Geometry::SlopeInterceptLine do
     end
 
     it 'must have an x-intercept' do
-	subject.intercept(:x).must_equal -2/3
+	subject.intercept(:x).must_equal(-2/3)
     end
 
     it 'must not have an x-intercept for horizontal lines' do
@@ -251,7 +251,7 @@ describe Geometry::TwoPointLine do
     end
 
     it 'must have an x-intercept' do
-	subject.intercept(:x).must_equal -1
+	subject.intercept(:x).must_equal(-1)
     end
 
     it 'must not have an x-intercept for horizontal lines' do

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

@@ -15,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
@@ -312,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,7 +2,7 @@ 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
@@ -83,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
@@ -115,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
@@ -231,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

@@ -126,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

@@ -127,7 +127,7 @@ describe Geometry::PointZero 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/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,7 +78,7 @@ 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

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