aurora-geometry 0.0.2

data/test/geometry/rotation.rb

@@ -0,0 +1,108 @@
+require 'minitest/autorun'
+require 'geometry/rotation'
+
+describe Geometry::Rotation do
+    Point = Geometry::Point
+    Rotation = Geometry::Rotation
+    RotationAngle = Geometry::RotationAngle
+
+    describe "when constructed" do
+	it "must accept a rotation angle" do
+	    rotation = Rotation.new angle:Math::PI/2
+	    rotation.must_be_instance_of(RotationAngle)
+	    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.y.must_be_close_to 0
+	end
+
+	it "must accept an X axis" do
+	    rotation = Rotation.new x:[1,0]
+	    rotation.must_be_instance_of(RotationAngle)
+	    rotation.angle.must_equal 0
+	    rotation.x.must_equal Point[1,0]
+	    rotation.y.must_equal Point[0,1]
+	end
+    end
+
+    it "must accept x and y axes" do
+	rotation = Geometry::Rotation.new :x => [1,2,3], :y => [4,5,6]
+	rotation.x.must_equal [1,2,3]
+	rotation.y.must_equal [4,5,6]
+    end
+
+    it "must accept 3-element x and y axes and a dimensionality of 3" do
+	rotation = Geometry::Rotation.new(:dimensions => 3, :x => [1,2,3], :y => [4,5,6])
+	rotation.dimensions.must_equal 3
+    end
+
+    it "must reject 3-element x and y axes and a dimensionality of 2" do
+	lambda { Geometry::Rotation.new(:dimensions => 2, :x => [1,2,3], :y => [4,5,6]) }.must_raise ArgumentError
+    end
+
+    it "must promote 2-element Vectors to dimensionality of 3" do
+	rotation = Geometry::Rotation.new(:dimensions => 3, :x => [1,2], :y => [4,5])
+	rotation.dimensions.must_equal 3
+	rotation.x.must_equal [1,2,0]
+	rotation.y.must_equal [4,5,0]
+    end
+
+    it "must be the identity rotation if no axes are given" do
+	Geometry::Rotation.new.identity?.must_equal true
+	Geometry::Rotation.new(:dimensions => 3).identity?.must_equal true
+    end
+
+    it "must be the identity rotation when identity axes are given" do
+	Geometry::Rotation.new(:x => [1,0,0], :y => [0,1,0])
+    end
+
+    it "must have a matrix accessor" do
+	r = Geometry::Rotation.new(:x => [1,0,0], :y => [0,1,0])
+	r.matrix.must_equal Matrix[[1,0,0],[0,1,0],[0,0,1]]
+    end
+
+    describe "when comparing" do
+	it "must equate equal objects" do
+	    Rotation.new(x:[1,2,3], y:[4,5,6]).must_equal Rotation.new(x:[1,2,3], y:[4,5,6])
+	end
+    end
+
+    describe "comparison" do
+	it "must equate equal angles" do
+	    Rotation.new(angle:45).must_equal Rotation.new(angle:45)
+	end
+
+	it "must not equate unequal angles" do
+	    Rotation.new(angle:10).wont_equal Rotation.new(angle:45)
+	end
+    end
+
+    describe "composition" do
+	it "must add angles" do
+	    (Rotation.new(angle:45) + Rotation.new(angle:45)).must_equal Rotation.new(angle:90)
+	end
+
+	it "must subtract angles" do
+	    (Rotation.new(angle:45) - Rotation.new(angle:45)).must_equal Rotation.new(angle:0)
+	end
+
+	it "must negate angles" do
+	    (-Rotation.new(angle:45)).must_equal Rotation.new(angle:-45)
+	end
+    end
+
+    describe "when transforming a Point" do
+	describe "when no rotation is set" do
+	    it "must return the Point" do
+		Rotation.new.transform(Point[1,0]).must_equal Point[1,0]
+	    end
+	end
+
+	it "must rotate" do
+	    rotated_point = Rotation.new(angle:Math::PI/2).transform(Point[1,0])
+	    rotated_point.x.must_be_close_to 0
+	    rotated_point.y.must_be_close_to 1
+	end
+    end
+end

data/test/geometry/size.rb

@@ -0,0 +1,97 @@
+require 'minitest/autorun'
+require 'geometry/size'
+
+describe Geometry::Size do
+    describe "when constructed" do
+	it "create a Size object using list syntax" do
+	    size = Geometry::Size[2,1]
+	    assert_equal(2, size.size)
+	    assert_equal(2, size.x)
+	    assert_equal(1, size.y)
+	end
+
+	it "create a Size object from an array" do
+	    size = Geometry::Size[[3,4]]
+	    assert_equal(2, size.size)
+	    assert_equal(3, size.x)
+	    assert_equal(4, size.y)
+	end
+
+	it "create a Size object from individual parameters" do
+	    size = Geometry::Size[3,4]
+	    assert_equal(2, size.size)
+	    assert_equal(3, size.x)
+	    assert_equal(4, size.y)
+	end
+
+	it "create a Size object from a Size" do
+	    size = Geometry::Size[Geometry::Size[3,4]]
+	    assert_equal(2, size.size)
+	    assert_equal(3, size.x)
+	    assert_equal(4, size.y)
+	end
+
+	it "create a Size object from a Vector" do
+	    size = Geometry::Size[Vector[3,4]]
+	    assert_equal(2, size.size)
+	    assert_equal(3, size.x)
+	    assert_equal(4, size.y)
+	end
+    end
+
+    it "allow indexed element access" do
+	size = Geometry::Size[5,6]
+	assert_equal(2, size.size)
+	assert_equal(5, size[0])
+	assert_equal(6, size[1])
+    end
+    it "allow named element access" do
+	size = Geometry::Size[5,6,7]
+	assert_equal(3, size.size)
+	assert_equal(5, size.x)
+	assert_equal(6, size.y)
+	assert_equal(7, size.z)
+    end
+
+    it "have a width accessor" do
+	size = Geometry::Size[5,6,7]
+	assert_equal(5, size.width)
+    end
+
+    it "have a height accessor" do
+	size = Geometry::Size[5,6,7]
+	assert_equal(6, size.height)
+    end
+
+    it "have a depth accessor" do
+	size = Geometry::Size[5,6,7]
+	assert_equal(7, size.depth)
+    end
+
+    it "compare equal" do
+	size1 = Geometry::Size[1,2]
+	size2 = Geometry::Size[1,2]
+	size3 = Geometry::Size[3,4]
+	assert_equal(size1, size2)
+	size2.wont_equal size3
+    end
+
+    it "compare equal to an array with equal elements" do
+	size1 = Size[1,2]
+	assert_equal(size1, [1,2])
+    end
+
+    it "not compare equal to an array with unequal elements" do
+	size1 = Size[1,2]
+	size1.wont_equal [3,2]
+    end
+
+    it "implement inspect" do
+	size = Geometry::Size[8,9]
+	assert_equal('Size[8, 9]', size.inspect)
+    end
+    it "implement to_s" do
+	size = Geometry::Size[10,11]
+	assert_equal('Size[10, 11]', size.to_s)
+    end
+end

data/test/geometry/size_zero.rb

@@ -0,0 +1,153 @@
+require 'minitest/autorun'
+require 'geometry/size_zero'
+
+describe Geometry::SizeZero do
+    Size = Geometry::Size
+
+    let(:zero) { Geometry::SizeZero.new }
+
+    describe "arithmetic" do
+	let(:left) { Size[1,2] }
+	let(:right) { Size[3,4] }
+	
+	it "must have +@" do
+	    (+zero).must_be :eql?, 0
+	    (+zero).must_be_instance_of(Geometry::SizeZero)
+	end
+	
+	it "must have unary negation" do
+	    (-zero).must_be :eql?, 0
+	    (-zero).must_be_instance_of(Geometry::SizeZero)
+	end
+	
+	describe "when adding" do
+	    it "must return a number" do
+		(zero + 3).must_equal 3
+		(3 + zero).must_equal 3
+	    end
+
+	    it "return a Size when adding two Sizes" do
+		(zero + right).must_be_kind_of Size
+#		(left + zero).must_be_kind_of Size
+	    end
+	    
+	    it "must return a Size when adding an array" do
+		(zero + [5,6]).must_equal [5,6]
+#		([5,6] + zero).must_equal [5,6]
+	    end
+	end
+	
+	describe "when subtracting" do
+	    it "must return a number" do
+		(zero - 3).must_equal -3
+		(3 - zero).must_equal 3
+	    end
+
+	    it "return a Size when subtracting two Size" do
+		(zero - right).must_equal Size[-3,-4]
+		(left - zero).must_equal Size[1,2]
+	    end
+	    
+	    it "must return a Size when subtracting an array" do
+		(zero - [5,6]).must_equal [-5, -6]
+#		([5,6] - zero).must_equal [5,6]
+	    end
+	end
+	
+	describe "multiplication" do
+	    it "must return 0 for scalars" do
+		(zero * 3).must_equal 0
+		(zero * 3.0).must_equal 0.0
+	    end
+
+	    it "must return 0 for Sizes" do
+		(zero * Size[1,2]).must_equal 0
+	    end
+
+	    it "must return 0 for Vectors" do
+		(zero * Vector[2,3]).must_equal 0
+	    end
+	end
+
+	describe "division" do
+	    it "must return 0 for non-zero scalars" do
+		(zero / 3).must_equal 0
+		(zero / 4.0).must_equal 0
+	    end
+
+	    it "must raise an exception when divided by 0" do
+		lambda { zero / 0 }.must_raise ZeroDivisionError
+	    end
+
+	    it "must raise an exception for Sizes" do
+		lambda { zero / Size[1,2] }.must_raise Geometry::OperationNotDefined
+	    end
+
+	    it "must raise an exception for Vectors" do
+		lambda { zero / Vector[1,2] }.must_raise Geometry::OperationNotDefined
+	    end
+
+	end
+
+    end
+
+    describe "coercion" do
+	it "must coerce Arrays into Sizes" do
+	    zero.coerce([3,4]).must_equal [Size[3,4], Size[0,0]]
+	end
+	
+	it "must coerce Vectors into Vectors" do
+	    zero.coerce(Vector[3,4]).must_equal [Vector[3,4], Vector[0,0]]
+	end
+
+	it "must coerce Size into Size" do
+	    zero.coerce(Size[5,6]).must_equal [Size[5,6], Size[0,0]]
+	end
+    end
+
+    describe "comparison" do
+	let(:zero) { Geometry::PointZero.new }
+	
+	it "must be equal to 0 and 0.0" do
+	    zero.must_be :eql?, 0
+	    zero.must_be :eql?, 0.0
+	end
+
+	it "must not be equal to a non-zero number" do
+	    1.wont_equal zero
+	    3.14.wont_equal zero
+	end
+
+	it "must be equal to an Array of zeros" do
+	    zero.must_be :==, [0,0]
+	    zero.must_be :eql?, [0,0]
+	    [0,0].must_equal zero
+	end
+	
+	it "must not be equal to a non-zero Array" do
+	    zero.wont_equal [3,2]
+	    [3,2].wont_equal zero
+	end
+	
+	it "must be equal to a zero Size" do
+	    zero.must_be :==, Size[0,0]
+	    zero.must_be :eql?, Size[0,0]
+	    Size[0,0].must_equal zero
+	end
+	
+	it "must not be equal to a non-zero Size" do
+	    zero.wont_equal Size[3,2]
+	    Size[3,2].wont_equal zero
+	end
+	
+	it "must be equal to an Vector of zeroes" do
+	    zero.must_be :eql?, Vector[0,0]
+	    Vector[0,0].must_equal zero
+	end
+	
+	it "must not be equal to a non-zero Vector" do
+	    zero.wont_equal Vector[3,2]
+	    Vector[3,2].wont_equal zero
+	end
+    end
+end

data/test/geometry/square.rb

@@ -0,0 +1,66 @@
+require 'minitest/autorun'
+require 'geometry/square'
+
+describe Geometry::Square do
+    Square = Geometry::Square
+
+    describe "when constructed" do
+	it "must create a Square from two Points" 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
+	    square.instance_eval('@points[0]').must_equal Point[1,2]
+	    square.instance_eval('@points[1]').must_equal Point[3,4]
+	end
+
+	it "must accept an origin Point and a size" do
+	    square = Square.new origin:[1,2], size:5
+	    square.must_be_kind_of Geometry::Square
+	    square.origin.must_equal Point[1,2]
+	    square.height.must_equal 5
+	    square.width.must_equal 5
+	end
+    end
+    
+    describe "properties" do
+	subject { Square.new from:[2,3], to:[3,4] }
+
+	it "must have an origin accessor" do
+	    subject.origin.must_equal Point[2,3]
+	end
+    end
+end
+
+describe Geometry::CenteredSquare do
+    describe "when constructed" do
+	it "must create a CenteredSquare from a center point and a size" do
+	    square = Geometry::CenteredSquare.new [2,3], 5
+	    square.must_be_instance_of Geometry::CenteredSquare
+	    square.must_be_kind_of Geometry::Square
+	end
+    end
+
+    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]]
+	end
+
+	it "must have a height property" do
+	    square.height.must_equal 4
+	end
+
+	it "must have a width property" do
+	    square.width.must_equal 4
+	end
+    end
+end

data/test/geometry/transformation.rb

@@ -0,0 +1,169 @@
+require 'minitest/autorun'
+require 'geometry/point'
+require 'geometry/transformation'
+
+describe Geometry::Transformation do
+    Transformation = Geometry::Transformation
+
+    describe "when constructed" do
+	it "must accept nothing and become an identity transformation" do
+	    Transformation.new.identity?.must_equal true
+	end
+
+	it "must accept a translate parameter" do
+	    Transformation.new([4,2]).translation.must_equal Point[4,2]
+	end
+
+	it "must accept a translate Array" do
+	    translate = Transformation.new(:translate => [4,2])
+	    translate.translation.must_equal Point[4,2]
+	end
+
+	it "must accept a translate Point" do
+	    translate = Transformation.new(:translate => Point[4,2])
+	    translate.translation.must_equal Point[4,2]
+	end
+
+	it "must accept a translate Point equal to zero" do
+	    translate = Transformation.new(:translate => [0,0])
+	    translate.translation.must_equal nil
+	end
+
+	it "must accept a translate Vector" do
+	    translate = Transformation.new(:translate => Vector[4,2])
+	    translate.translation.must_equal Point[4,2]
+	end
+
+	it "must accept an origin option" do
+	    translate = Transformation.new(:origin => [4,2])
+	    translate.translation.must_equal Point[4,2]
+	end
+
+	it "must raise an exception when given too many translation options" do
+	    lambda { Transformation.new :translate => [1,2], :origin => [3,4] }.must_raise ArgumentError
+	end
+
+	describe "when given a dimensions option" do
+	    it "must raise an exception if the other arguments are too big" do
+		lambda { Transformation.new :dimensions => 2, :origin => [1,2,3] }.must_raise ArgumentError
+	    end
+
+	    it "must raise an exception if the other arguments are too small" do
+		lambda { Transformation.new :dimensions => 3, :origin => [1,2] }.must_raise ArgumentError
+	    end
+
+	    it "must not complain when given only a dimensions option" do
+		Transformation.new(:dimensions => 3).dimensions.must_equal 3
+	    end
+	end
+
+	describe "rotation" do
+	    it "must accept a y axis option" do
+		t = Transformation.new :y => [1,0]
+		t.rotation.y.must_equal [1,0]
+		t.identity?.wont_equal true
+	    end
+
+	    it "must accept a rotation angle" do
+		transformation = Transformation.new angle:90
+		transformation.identity?.wont_equal true
+		transformation.rotation.wont_be_nil
+		transformation.rotation.angle.must_equal 90
+	    end
+
+	    it "must accept a rotation angle specified by an X-axis" do
+		transformation = Transformation.new x:[0,1]
+		rotation = transformation.rotation
+		rotation.must_be_instance_of(RotationAngle)
+		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.y.must_be_close_to 0
+	    end
+	end
+    end
+
+    describe "comparison" do
+	subject { Transformation.new(origin:[1,2]) }
+
+	it "must equate equal transformations" do
+	    subject.must_equal Transformation.new(origin:[1,2])
+	end
+
+	it "must not equal nil" do
+	    subject.eql?(nil).wont_equal true
+	end
+
+	it "must not equate a translation with a rotation" do
+	    subject.wont_equal Transformation.new(x:[0,1,0], y:[1,0,0])
+	end
+
+	it "must equate empty transformations" do
+	    Transformation.new.must_equal Transformation.new
+	end
+    end
+
+    describe "attributes" do
+	describe "has_rotation?" do
+	    it "must properly be true" do
+		Transformation.new(angle:90).has_rotation?.must_equal true
+	    end
+
+	    it "must properly be false" do
+		Transformation.new.has_rotation?.must_equal false
+	    end
+	end
+    end
+
+    describe "composition" do
+	let(:translate_left) { Geometry::Transformation.new origin:[-2,-2] }
+	let(:translate_right) { Geometry::Transformation.new origin:[1,1] }
+	let(:transformation) { Geometry::Transformation.new }
+
+	it "must add pure translation" do
+	    (translate_left + translate_right).must_equal Geometry::Transformation.new origin:[-1,-1]
+	end
+
+	it "must add translation and no translation" do
+	    (transformation + translate_left).must_equal translate_left
+	    (translate_left + transformation).must_equal translate_left
+	end
+
+	it "array addition" do
+	    (transformation + [1,2]).translation.must_equal Point[1,2]
+	    ((transformation + [1,2]) + [2,3]).translation.must_equal Point[3,5]
+	    (transformation + [1,2]).rotation.must_be_nil
+	end
+
+	it "must update the translation when an array is subtracted" do
+	    (transformation - [1,2]).translation.must_equal Point[-1,-2]
+	    ((transformation - [1,2]) - [2,3]).translation.must_equal Point[-3,-5]
+	    (transformation - [1,2,3]).rotation.must_be_nil
+	end
+
+	it "must subtract translation and no translation" do
+	    (transformation - translate_left).must_equal translate_left
+	    (translate_left - transformation).must_equal translate_left
+	end
+    end
+
+    describe "when transforming a Point" do
+	describe "when no transformation is set" do
+	    it "must return the Point" do
+		Transformation.new.transform(Point[1,2]).must_equal Point[1,2];
+	    end
+	end
+
+	it "must translate" do
+	    Geometry::Transformation.new(origin:[0,1]).transform([1,0]).must_equal Point[1,1]
+	end
+
+	it "must rotate" do
+	    rotated_point = Transformation.new(angle:Math::PI/2).transform([1,0])
+	    rotated_point.x.must_be_close_to 0
+	    rotated_point.y.must_be_close_to 1
+	end
+
+    end
+end