geometry-in-ruby 0.0.1

data/test/geometry/regular_polygon.rb

@@ -0,0 +1,120 @@
+require 'minitest/autorun'
+require 'geometry/regular_polygon'
+
+describe Geometry::RegularPolygon do
+    RegularPolygon = Geometry::RegularPolygon
+
+    describe "when constructed with named center and radius arguments" do
+	let(:polygon) { RegularPolygon.new sides:4, center:[1,2], radius:3 }
+	subject { RegularPolygon.new sides:4, center:[1,2], radius:3 }
+
+	it "must create a RegularPolygon" do
+	    polygon.must_be_instance_of(RegularPolygon)
+	end
+
+	it "must have the correct number of sides" do
+	    polygon.edge_count.must_equal 4
+	end
+
+	it "must have a center point accessor" do
+	    polygon.center.must_equal Point[1,2]
+	end
+
+	it "must have a radius accessor" do
+	    polygon.radius.must_equal 3
+	end
+
+	it "must compare equal" do
+	    polygon.must_equal RegularPolygon.new(sides:4, center:[1,2], radius:3)
+	end
+
+	describe "properties" do
+	    it "must have vertices" do
+		subject.vertices.must_equal [Point[4.0, 2.0], Point[1.0000000000000002, 5.0], Point[-2.0, 2.0000000000000004], Point[0.9999999999999994, -1.0]]
+	    end
+	end
+    end
+
+    describe "when constructed with a center and diameter" do
+	let(:polygon) { RegularPolygon.new sides:4, center:[1,2], diameter:4 }
+
+	it "must be a DiameterRegularPolygon" do
+	    polygon.must_be_instance_of(Geometry::DiameterRegularPolygon)
+	    polygon.must_be_kind_of(RegularPolygon)
+	end
+
+	it "must have the correct number of sides" do
+	    polygon.edge_count.must_equal 4
+	end
+
+	it "must have a center" do
+	    polygon.center.must_equal Point[1,2]
+	end
+
+	it "must have a diameter" do
+	    polygon.diameter.must_equal 4
+	end
+
+	it "must calculate the correct radius" do
+	    polygon.radius.must_equal 2
+	end
+
+	it "must compare equal" do
+	    polygon.must_equal RegularPolygon.new(sides:4, center:[1,2], diameter:4)
+	end
+    end
+
+    describe "when constructed with a diameter and no center" do
+	let(:polygon) { RegularPolygon.new sides:4, diameter:4 }
+
+	it "must be a DiameterRegularPolygon" do
+	    polygon.must_be_instance_of(Geometry::DiameterRegularPolygon)
+	    polygon.must_be_kind_of(RegularPolygon)
+	end
+
+	it "must have the correct number of sides" do
+	    polygon.edge_count.must_equal 4
+	end
+
+	it "must be at the origin" do
+	    polygon.center.must_equal Point.zero
+	end
+
+	it "must have a diameter" do
+	    polygon.diameter.must_equal 4
+	end
+
+	it "must calculate the correct radius" do
+	    polygon.radius.must_equal 2
+	end
+    end
+
+    describe "properties" do
+	subject { RegularPolygon.new sides:6, diameter:4 }
+
+	it "must have edges" do
+	    expected_edges = [Edge(Point[2, 0], Point[1, 1.732]), Edge(Point[1, 1.732], Point[-1, 1.732]), Edge(Point[-1, 1.732], Point[-2, 0]), Edge(Point[-2, 0], Point[-1, -1.732]), Edge(Point[-1, -1.732], Point[1, -1.732]), Edge(Point[1, -1.732], Point[2, 0])]
+	    subject.edges.zip(expected_edges) do |edge1, edge2|
+		edge1.to_a.zip(edge2.to_a) do |point1, point2|
+		    point1.to_a.zip(point2.to_a) {|a, b| a.must_be_close_to b }
+		end
+	    end
+	end
+
+	it "must have a bounds property that returns a Rectangle" do
+	    subject.bounds.must_equal Rectangle.new([-2,-2], [2,2])
+	end
+
+	it "must have a minmax property that returns the corners of the bounding rectangle" do
+	    subject.minmax.must_equal [Point[-2,-2], Point[2,2]]
+	end
+
+	it "must have a max property that returns the upper right corner of the bounding rectangle" do
+	    subject.max.must_equal Point[2,2]
+	end
+
+	it "must have a min property that returns the lower left corner of the bounding rectangle" do
+	    subject.min.must_equal Point[-2,-2]
+	end
+    end
+end

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/composition.rb

@@ -0,0 +1,49 @@
+require 'minitest/autorun'
+require 'geometry/transformation/composition'
+
+describe Geometry::Transformation::Composition do
+    Composition = Geometry::Transformation::Composition
+    Transformation = Geometry::Transformation
+
+    subject { Composition.new }
+
+    describe "when constructed" do
+	it "must accept multiple transformations" do
+	    composition = Composition.new(Transformation.new, Transformation.new)
+	    composition.size.must_equal 2
+	end
+
+	it "must reject anything that isn't a Transformation" do
+	    -> { Composition.new :foo }.must_raise TypeError
+	end
+    end
+
+    describe "attributes" do
+	describe "has_rotation?" do
+	    it "must properly be true" do
+		Composition.new(Transformation.new angle:90).has_rotation?.must_equal true
+	    end
+
+	    it "must properly be false" do
+		subject.has_rotation?.must_equal false
+	    end
+	end
+    end
+
+    describe "when composing" do
+	it "must append a Transformation" do
+	    (Composition.new(Transformation.new) + Transformation.new).size.must_equal 2
+	end
+
+	it "must merge with a Composition" do
+	    (Composition.new(Transformation.new) + Composition.new(Transformation.new)).size.must_equal 2
+	end
+    end
+
+    describe "when transforming a Point" do
+	it "must handle composed translations" do
+	    composition = Composition.new(Transformation.new origin:[1,2]) + Composition.new(Transformation.new [3,4])
+	    composition.transform(Point[5,6]).must_equal Point[9, 12]
+	end
+    end
+end