cornerstone-source 0.1.1

data/source/javascripts/_test/function_extensions.coffee

@@ -0,0 +1,50 @@
+module "Function"
+
+test "#once", ->
+  score = 0
+
+  addScore = ->
+    score += 100
+
+  onceScore = addScore.once()
+
+  100.times ->
+    onceScore()
+
+  equals score, 100
+
+test "#returning", ->
+  x = 0
+  sideEffectsAdd = (a) ->
+    x += a
+
+  returnValue = sideEffectsAdd.returning(-1)(4)
+
+  equals x, 4
+  equals returnValue, -1
+
+asyncTest "#debounce", 1, ->
+  fn = (-> ok true; start()).debounce(50)
+
+  # Though called multiple times the function is only triggered once
+  fn()
+  fn()
+  fn()
+
+asyncTest "#delay", 2, ->
+  fn = (x, y) ->
+    equals x, 3
+    equals y, "testy"
+    start()
+
+  fn.delay 25, 3, "testy"
+
+asyncTest "#defer", 1, ->
+  fn = (x) -> 
+    equals x, 3
+    start()
+
+  fn.defer 3
+
+module()
+

data/source/javascripts/_test/logging.coffee

@@ -0,0 +1,7 @@
+module "Logging"
+
+test "log exists", ->
+  ok(log)
+
+module()
+

data/source/javascripts/_test/matrix.coffee

@@ -0,0 +1,174 @@
+( ->
+  module "Matrix"
+
+  TOLERANCE = 0.00001
+
+  equalEnough = (expected, actual, tolerance, message) ->
+    message ||= "" + expected + " within " + tolerance + " of " + actual
+    ok(expected + tolerance >= actual && expected - tolerance <= actual, message)
+
+  matrixEqual = (m1, m2) ->
+    equalEnough(m1.a, m2.a, TOLERANCE)
+    equalEnough(m1.b, m2.b, TOLERANCE)
+    equalEnough(m1.c, m2.c, TOLERANCE)
+    equalEnough(m1.d, m2.d, TOLERANCE)
+    equalEnough(m1.tx, m2.tx, TOLERANCE)
+    equalEnough(m1.ty, m2.ty, TOLERANCE)
+
+  test "copy constructor", ->
+   matrix = Matrix(1, 0, 0, 1, 10, 12)
+
+   matrix2 = Matrix(matrix)
+
+   ok matrix != matrix2
+   matrixEqual(matrix2, matrix)
+
+  test "Matrix() (Identity)", ->
+    matrix = Matrix()
+
+    equals(matrix.a, 1, "a")
+    equals(matrix.b, 0, "b")
+    equals(matrix.c, 0, "c")
+    equals(matrix.d, 1, "d")
+    equals(matrix.tx, 0, "tx")
+    equals(matrix.ty, 0, "ty")
+
+    matrixEqual(matrix, Matrix.IDENTITY)
+
+  test "Empty", ->
+    matrix = Matrix(0, 0, 0, 0, 0, 0)
+
+    equals(matrix.a, 0, "a")
+    equals(matrix.b, 0, "b")
+    equals(matrix.c, 0, "c")
+    equals(matrix.d, 0, "d")
+    equals(matrix.tx, 0, "tx")
+    equals(matrix.ty, 0, "ty")
+
+  test "#copy", ->
+    matrix = Matrix(2, 0, 0, 2)
+
+    copyMatrix = matrix.copy()
+
+    matrixEqual copyMatrix, matrix
+
+    copyMatrix.a = 4
+
+    equals copyMatrix.a, 4
+    equals matrix.a, 2, "Old 'a' value is unchanged"
+
+  test ".scale", ->
+    matrix = Matrix.scale(2, 2)
+
+    equals(matrix.a, 2, "a")
+    equals(matrix.b, 0, "b")
+    equals(matrix.c, 0, "c")
+    equals(matrix.d, 2, "d")
+
+    matrix = Matrix.scale(3)
+
+    equals(matrix.a, 3, "a")
+    equals(matrix.b, 0, "b")
+    equals(matrix.c, 0, "c")
+    equals(matrix.d, 3, "d")
+
+  test ".scale (about a point)", ->
+    p = Point(5, 17)
+
+    transformedPoint = Matrix.scale(3, 7, p).transformPoint(p)
+
+    equals(transformedPoint.x, p.x, "Point should remain the same")
+    equals(transformedPoint.y, p.y, "Point should remain the same")
+
+  test "#scale (about a point)", ->
+    p = Point(3, 11)
+
+    transformedPoint = Matrix.IDENTITY.scale(3, 7, p).transformPoint(p)
+
+    equals(transformedPoint.x, p.x, "Point should remain the same")
+    equals(transformedPoint.y, p.y, "Point should remain the same")
+
+  test "#skew", ->
+    matrix = Matrix()
+
+    matrix = matrix.skew(0.125.turns, 0)
+
+    equals matrix.c, Math.tan(0.125.turns)
+
+  test ".rotation", ->
+    matrix = Matrix.rotation(Math.PI / 2)
+
+    equalEnough(matrix.a, 0, TOLERANCE)
+    equalEnough(matrix.b, 1, TOLERANCE)
+    equalEnough(matrix.c,-1, TOLERANCE)
+    equalEnough(matrix.d, 0, TOLERANCE)
+
+  test ".rotation (about a point)", ->
+    p = Point(11, 7)
+
+    transformedPoint = Matrix.rotation(Math.PI / 2, p).transformPoint(p)
+
+    equals transformedPoint.x, p.x, "Point should remain the same"
+    equals transformedPoint.y, p.y, "Point should remain the same"
+
+  test "#rotate (about a point)", ->
+    p = Point(8, 5);
+
+    transformedPoint = Matrix.IDENTITY.rotate(Math.PI / 2, p).transformPoint(p)
+
+    equals transformedPoint.x, p.x, "Point should remain the same"
+    equals transformedPoint.y, p.y, "Point should remain the same"
+
+  test "#inverse (Identity)", ->
+    matrix = Matrix().inverse()
+
+    equals(matrix.a, 1, "a")
+    equals(matrix.b, 0, "b")
+    equals(matrix.c, 0, "c")
+    equals(matrix.d, 1, "d")
+    equals(matrix.tx, 0, "tx")
+    equals(matrix.ty, 0, "ty")
+
+  test "#concat", ->
+    matrix = Matrix.rotation(Math.PI / 2).concat(Matrix.rotation(-Math.PI / 2))
+
+    matrixEqual(matrix, Matrix.IDENTITY)
+
+  test "#toString", ->
+    matrix = Matrix(0.5, 2, 0.5, -2, 3, 4.5)
+    matrixEqual eval(matrix.toString()), matrix
+
+  test "Maths", ->
+    a = Matrix(12, 3, 3, 1, 7, 9)
+    b = Matrix(3, 8, 3, 2, 1, 5)
+
+    c = a.concat(b)
+
+    equals(c.a, 60)
+    equals(c.b, 17)
+    equals(c.c, 42)
+    equals(c.d, 11)
+    equals(c.tx, 34)
+    equals(c.ty, 17)
+
+  test "Order of transformations should match manual concat", ->
+    tx = 10
+    ty = 5
+    theta = Math.PI/3
+    s = 2
+
+    m1 = Matrix().translate(tx, ty).scale(s).rotate(theta)
+    m2 = Matrix().concat(Matrix.translation(tx, ty)).concat(Matrix.scale(s)).concat(Matrix.rotation(theta))
+
+    matrixEqual(m1, m2)
+
+  test "IDENTITY is immutable", ->
+    identity = Matrix.IDENTITY
+
+    identity.a = 5
+
+    equals identity.a, 1
+
+  module undefined
+)()
+

data/source/javascripts/_test/number_extensions.coffee

@@ -0,0 +1,138 @@
+equalEnough = (expected, actual, tolerance, message) ->
+  message ||= "" + expected + " within " + tolerance + " of " + actual
+  ok(expected + tolerance >= actual && expected - tolerance <= actual, message)
+
+module "Number"
+
+test "#abs", ->
+  equals 5.abs(), 5, "(5).abs() equals 5"
+  equals 4.2.abs(), 4.2, "(4.2).abs() equals 4.2"
+  equals (-1.2).abs(), 1.2, "(-1.2).abs() equals 1.2"
+  equals 0.abs(), 0, "(0).abs() equals 0"
+
+test "#ceil", ->
+  equals 4.9.ceil(), 5, "(4.9).floor() equals 5"
+  equals 4.2.ceil(), 5, "(4.2).ceil() equals 5"
+  equals (-1.2).ceil(), -1, "(-1.2).ceil() equals -1"
+  equals 3.ceil(), 3, "(3).ceil() equals 3"
+  
+test "#clamp", ->
+  equals 5.clamp(0, 3), 3
+  equals 5.clamp(-1, 0), 0
+  equals (-5).clamp(0, 1), 0
+  equals 1.clamp(0, null), 1
+  equals (-1).clamp(0, null), 0
+  equals (-10).clamp(-5, 0), -5
+  equals (-10).clamp(null, 0), -10
+  equals 50.clamp(null, 10), 10
+
+test "#floor", ->
+  equals 4.9.floor(), 4, "(4.9).floor() equals 4"
+  equals 4.2.floor(), 4, "(4.2).floor() equals 4"
+  equals (-1.2).floor(), -2, "(-1.2).floor() equals -2"
+  equals 3.floor(), 3, "(3).floor() equals 3"
+
+test "#round", ->
+  equals 4.5.round(), 5, "(4.5).round() equals 5"
+  equals 4.4.round(), 4, "(4.4).round() equals 4"
+
+test "#sign", ->
+  equals 5.sign(), 1, "Positive number's sign is 1"
+  equals (-3).sign(), -1, "Negative number's sign is -1"
+  equals 0.sign(), 0, "Zero's sign is 0"
+
+test "#even", ->
+  [0, 2, -32].each (n) ->
+    ok n.even(), "#{n} is even"
+
+  [1, -1, 2.2, -3.784].each (n) ->
+    equals n.even(), false, "#{n} is not even"
+
+test "#odd", ->
+  [1, 9, -37].each (n) ->
+    ok n.odd(), "#{n} is odd"
+
+  [0, 32, 2.2, -1.1].each (n) ->
+    equals n.odd(), false, "#{n} is not odd"
+
+test "#times", ->
+  n = 5
+  equals n.times(->), n, "returns n"
+
+test "#times called correct amount", ->
+  n = 5
+  count = 0
+
+  n.times -> count++
+
+  equals n, count, "returns n"
+
+test "#constrainRotation", ->
+  equals (Math.PI * 5).constrainRotation(), Math.PI
+  equals (-Math.PI * 5).constrainRotation(), -Math.PI
+
+  equals (Math.TAU/4 * 5).constrainRotation(), Math.TAU/4
+  equals (Math.TAU/4 * 3).constrainRotation(), -Math.TAU/4
+
+test "#mod should have a positive result when used with a positive base and a negative number", ->
+  n = -3
+
+  equals n.mod(8), 5, "Should 'wrap' and be positive."
+
+test "#primeFactors", ->
+
+  factors = 15.primeFactors()
+
+  equals factors.length, 2
+  equals factors[0], 3
+  equals factors[1], 5
+  equals factors.product(), 15
+
+  factors = 256.primeFactors()
+
+  equals factors.product(), 256
+  equals factors.length, 8
+  equals factors.first(), 2
+  equals factors.last(), 2
+
+  factors = 997.primeFactors()
+
+  equals factors.length, 1
+  equals factors.first(), 997
+  equals factors.product(), 997
+
+  equals 0.primeFactors(), undefined
+
+  factors = (-3).primeFactors()
+  equals factors.first(), -1
+  equals factors.product(), -3
+
+test "#seconds", ->
+  equals 1.second, 1000
+  equals 3.seconds, 3000
+
+test "#degrees", ->
+  equals 180.degrees, Math.PI
+  equals 1.degree, Math.TAU / 360
+
+test "#rotations", ->
+  equals 1.rotation, Math.TAU
+  equals 0.5.rotations, Math.TAU / 2
+  
+test "#turns", ->
+  equals 1.turn, Math.TAU
+  equals 0.5.turns, Math.TAU / 2
+  
+test "#circularPoints", ->
+  points = [
+    Point(1, 0)
+    Point(0, 1)
+    Point(-1, 0)
+    Point(0, -1)
+  ]
+
+  4.circularPoints (p, i) ->
+    equalEnough p.x, points[i].x, 0.001
+    equalEnough p.y, points[i].y, 0.001
+
+module undefined

data/source/javascripts/_test/object_extensions.coffee

@@ -0,0 +1,53 @@
+module "Object"
+
+test "isArray", ->
+  array = [1,2,3]
+  object = {
+    blah: "blah"
+    second: "another"
+  }
+  number = 5
+  string = "string"
+
+  ok Object.isArray(array), "an array is an array"
+  ok !Object.isArray(object), "an object is not an array"
+  ok !Object.isArray(number), "a number is not an array"
+  ok !Object.isArray(string), "a string is not array"
+
+test "isString", ->
+  ok Object.isString("a string"), "'a string' is a string"
+  ok !Object.isString([1, 2, 4]), "an array is not a string"
+  ok !Object.isString({key: "value"}), "an object literal is not a string"
+
+test "reverseMerge", ->
+  object =
+    test: true
+    b: "b"
+
+  Object.reverseMerge object,
+    test: false
+    c: "c"
+
+  ok object.test
+  equals object.c, "c"
+
+test "extend", ->
+  object =
+    test: true
+    b: "b"
+
+  Object.extend object,
+    test: false
+    c: "c"
+
+  equals object.test, false
+  equals object.b, "b"
+  equals object.c, "c"
+
+test "isObject", ->
+  object = {}
+
+  equals Object.isObject(object), true
+
+module()
+

data/source/javascripts/_test/point.coffee

@@ -0,0 +1,196 @@
+( ->
+  module "Point"
+
+  TOLERANCE = 0.00001
+
+  equalEnough = (expected, actual, tolerance, message) ->
+    message ||= "" + expected + " within " + tolerance + " of " + actual
+    ok(expected + tolerance >= actual && expected - tolerance <= actual, message)
+
+  test "copy constructor", ->
+    p = Point(3, 7)
+
+    p2 = Point(p)
+
+    equals p2.x, p.x
+    equals p2.y, p.y
+
+  test "#add", ->
+    p1 = Point(5, 6)
+    p2 = Point(7, 5)
+
+    result = p1.add(p2)
+
+    equals result.x, p1.x + p2.x
+    equals result.y, p1.y + p2.y
+
+    equals p1.x, 5
+    equals p1.y, 6
+    equals p2.x, 7
+    equals p2.y, 5
+
+  test "#add with two arguments", ->
+    point = Point(3, 7)
+    x = 2
+    y = 1
+
+    result = point.add(x, y)
+
+    equals result.x, point.x + x
+    equals result.y, point.y + y
+
+    x = 2
+    y = 0
+
+    result = point.add(x, y)
+
+    equals result.x, point.x + x
+    equals result.y, point.y + y
+
+  test "#add$", ->
+    p = Point(0, 0)
+
+    p.add$(Point(3, 5))
+
+    equals p.x, 3
+    equals p.y, 5
+
+    p.add$(2, 1)
+
+    equals p.x, 5
+    equals p.y, 6
+
+  test "#subtract", ->
+    p1 = Point(5, 6)
+    p2 = Point(7, 5)
+
+    result = p1.subtract(p2)
+
+    equals result.x, p1.x - p2.x
+    equals result.y, p1.y - p2.y
+
+  test "#subtract$", ->
+    p = Point(8, 6)
+
+    p.subtract$(3, 4)
+
+    equals p.x, 5
+    equals p.y, 2
+
+  test "#norm", ->
+    p = Point(2, 0)
+
+    normal = p.norm()
+    equals normal.x, 1
+
+    normal = p.norm(5)    
+    equals normal.x, 5
+
+    p = Point(0, 0)
+
+    normal = p.norm()
+    equals normal.x, 0, "x value of norm of point(0,0) is 0"
+    equals normal.y, 0, "y value of norm of point(0,0) is 0"
+
+  test "#norm$", ->
+    p = Point(6, 8)
+
+    p.norm$(5)
+
+    equals p.x, 3
+    equals p.y, 4
+
+  test "#scale", ->
+    p = Point(5, 6)
+    scalar = 2
+
+    result = p.scale(scalar)
+
+    equals result.x, p.x * scalar
+    equals result.y, p.y * scalar
+
+    equals p.x, 5
+    equals p.y, 6
+
+  test "#scale$", ->
+    p = Point(0, 1)
+    scalar = 3
+
+    p.scale$(scalar)
+
+    equals p.x, 0
+    equals p.y, 3
+
+  test "#floor", ->
+    p1 = Point(7.2, 6.9)
+
+    ok Point(7, 6).equal(p1.floor())
+
+  test "#floor$", ->
+    p1 = Point(7.2, 6.9)
+
+    p1.floor$()
+
+    ok Point(7, 6).equal(p1)
+
+  test "#equal", ->
+    ok Point(7, 8).equal(Point(7, 8))
+
+  test "#magnitude", ->
+    equals Point(3, 4).magnitude(), 5
+
+  test "#length", ->
+    equals Point(0, 0).length(), 0
+    equals Point(-1, 0).length(), 1
+
+  test "#toString", ->
+    p = Point(7, 5)
+    ok eval(p.toString()).equal(p)
+    
+  test "#clamp", ->
+    p = Point(10, 10)
+    p2 = p.clamp(5)
+    
+    equals p2.length(), 5
+
+  test ".centroid", ->
+    centroid = Point.centroid(
+      Point(0, 0),
+      Point(10, 10),
+      Point(10, 0),
+      Point(0, 10)
+    )
+
+    equals centroid.x, 5
+    equals centroid.y, 5
+
+  test ".fromAngle", ->
+    p = Point.fromAngle(Math.TAU / 4)
+
+    equalEnough p.x, 0, TOLERANCE
+    equals p.y, 1
+    
+  test ".random", ->
+    p = Point.random()
+
+    ok p
+
+  test ".interpolate", ->
+    p1 = Point(10, 7)
+    p2 = Point(-6, 29)
+
+    ok p1.equal(Point.interpolate(p1, p2, 0))
+    ok p2.equal(Point.interpolate(p1, p2, 1))
+
+  test "ZERO is immutable", ->
+    zero= Point.ZERO
+
+    zero.x = 5
+    zero.y = 2
+
+    equals zero.x, 0
+    equals zero.y, 0
+
+  module undefined
+)()
+