cornerstone-source 0.1.1

data/source/javascripts/_cornerstone/uuid.js

@@ -0,0 +1,96 @@
+/*!
+Math.uuid.js (v1.4)
+http://www.broofa.com
+mailto:robert@broofa.com
+
+Copyright (c) 2010 Robert Kieffer
+Dual licensed under the MIT and GPL licenses.
+*/
+
+/**
+Generate a random uuid.
+
+<code><pre>
+   // No arguments  - returns RFC4122, version 4 ID
+   Math.uuid()
+=> "92329D39-6F5C-4520-ABFC-AAB64544E172"
+
+   // One argument - returns ID of the specified length
+   Math.uuid(15)     // 15 character ID (default base=62)
+=> "VcydxgltxrVZSTV"
+
+   // Two arguments - returns ID of the specified length, and radix. (Radix must be <= 62)
+   Math.uuid(8, 2)  // 8 character ID (base=2)
+=> "01001010"
+
+   Math.uuid(8, 10) // 8 character ID (base=10)
+=> "47473046"
+
+   Math.uuid(8, 16) // 8 character ID (base=16)
+=> "098F4D35"
+</pre></code>
+
+@name uuid
+@methodOf Math
+@param length The desired number of characters
+@param radix  The number of allowable values for each character.
+ */
+(function() {
+  // Private array of chars to use
+  var CHARS = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'.split(''); 
+
+  Math.uuid = function (len, radix) {
+    var chars = CHARS, uuid = [];
+    radix = radix || chars.length;
+
+    if (len) {
+      // Compact form
+      for (var i = 0; i < len; i++) uuid[i] = chars[0 | Math.random()*radix];
+    } else {
+      // rfc4122, version 4 form
+      var r;
+
+      // rfc4122 requires these characters
+      uuid[8] = uuid[13] = uuid[18] = uuid[23] = '-';
+      uuid[14] = '4';
+
+      // Fill in random data.  At i==19 set the high bits of clock sequence as
+      // per rfc4122, sec. 4.1.5
+      for (var i = 0; i < 36; i++) {
+        if (!uuid[i]) {
+          r = 0 | Math.random()*16;
+          uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r];
+        }
+      }
+    }
+
+    return uuid.join('');
+  };
+
+  // A more performant, but slightly bulkier, RFC4122v4 solution.  We boost performance
+  // by minimizing calls to random()
+  Math.uuidFast = function() {
+    var chars = CHARS, uuid = new Array(36), rnd=0, r;
+    for (var i = 0; i < 36; i++) {
+      if (i==8 || i==13 ||  i==18 || i==23) {
+        uuid[i] = '-';
+      } else if (i==14) {
+        uuid[i] = '4';
+      } else {
+        if (rnd <= 0x02) rnd = 0x2000000 + (Math.random()*0x1000000)|0;
+        r = rnd & 0xf;
+        rnd = rnd >> 4;
+        uuid[i] = chars[(i == 19) ? (r & 0x3) | 0x8 : r];
+      }
+    }
+    return uuid.join('');
+  };
+
+  // A more compact, but less performant, RFC4122v4 solution:
+  Math.uuidCompact = function() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function(c) {
+      var r = Math.random()*16|0, v = c == 'x' ? r : (r&0x3|0x8);
+      return v.toString(16);
+    }).toUpperCase();
+  };
+})();

data/source/javascripts/_test/array_extensions.coffee

@@ -0,0 +1,173 @@
+module "Array"
+
+test "#average", ->
+  equals [1, 3, 5, 7].average(), 4
+
+test "#compact", ->
+  a = [0, 1, undefined, 2, null, 3, '', 4]
+
+  compacted = a.compact()
+
+  equals(compacted[0], 0)
+  equals(compacted[1], 1)
+  equals(compacted[2], 2)
+  equals(compacted[3], 3)
+  equals(compacted[4], '')
+  equals(compacted[5], 4)
+
+test "#copy", ->
+  a = [1,2,3]
+  b = a.copy()
+
+  ok a != b, "Original array is not the same array as the copied one"
+  ok a.length == b.length, "Both arrays are the same size"
+  ok a[0] == b[0] && a[1] == b[1] && a[2] == b[2], "The elements of the two arrays are equal"
+
+test "#flatten", ->
+  array = [[0,1], [2,3], [4,5]]
+
+  flattenedArray = array.flatten()
+
+  equals flattenedArray.length, 6, "Flattened array length should equal number of elements in sub-arrays"
+  equals flattenedArray.first(), 0, "First element should be first element in first sub-array"
+  equals flattenedArray.last(), 5, "Last element should be last element in last sub-array"
+
+test "#rand", ->
+  array = [1,2,3]
+
+  ok array.indexOf(array.rand()) != -1, "Array includes randomly selected element"
+  ok [5].rand() == 5, "[5].rand() === 5"
+  ok [].rand() == undefined, "[].rand() === undefined"
+
+test "#remove", ->
+  equals [1,2,3].remove(2), 2, "[1,2,3].remove(2) === 2"
+  equals [1,3].remove(2), undefined, "[1,3].remove(2) === undefined"
+  equals [1,3].remove(3), 3, "[1,3].remove(3) === 3"
+
+  array = [1,2,3]
+  array.remove(2)
+  ok array.length == 2, "array = [1,2,3]; array.remove(2); array.length === 2"
+  array.remove(3)
+  ok array.length == 1, "array = [1,3]; array.remove(3); array.length === 1"
+
+test "#map", ->
+  equals [1].map((x) -> return x + 1 )[0], 2
+
+test "#invoke", ->
+  results = ['hello', 'world', 'cool!'].invoke('substring', 0, 3)
+
+  equals results[0], "hel"
+  equals results[1], "wor"
+  equals results[2], "coo"
+
+test "#each", ->
+  array = [1, 2, 3]
+  count = 0
+
+  equals array, array.each -> count++
+  equals array.length, count
+
+test "#eachPair", ->
+  array = [1, 2, 3]
+  sum = 0
+
+  array.eachPair (a, b) ->
+    sum += a + b
+
+  equals(sum, 12)
+
+test "#eachWithObject", ->
+  array = [1, 2, 3]
+
+  result = array.eachWithObject {}, (element, hash) ->
+    hash[element] = (element + 1).toString()
+
+  equals result[1], "2"
+  equals result[2], "3"
+  equals result[3], "4"
+
+test "#shuffle", ->
+  array = [0, 1, 2, 3, 4, 5]
+
+  shuffledArray = array.shuffle()
+
+  shuffledArray.each (element) ->
+    ok array.indexOf(element) >= 0, "Every element in shuffled array is in orig array"
+
+  array.each (element) ->
+    ok shuffledArray.indexOf(element) >= 0, "Every element in orig array is in shuffled array"
+
+test "#first", ->
+  equals [2].first(), 2
+  equals [1, 2, 3].first(), 1
+  equals [].first(), undefined
+
+test "#last", ->
+  equals [2].last(), 2
+  equals [1, 2, 3].last(), 3
+  equals [].first(), undefined
+
+test "#extremes", ->
+  array = [-7, 1, 11, 94]
+
+  extremes = array.extremes()
+
+  equals extremes.min, -7, "Min is -7"
+  equals extremes.max, 94, "Max is 94"
+
+  extremes = array.extremes (value) ->
+    value.mod 11
+
+  equals extremes.min, 11
+  equals extremes.max, 94
+
+test "#sum", ->
+  equals [].sum(), 0, "Empty array sums to zero"
+  equals [2].sum(), 2, "[2] sums to 2"
+  equals [1, 2, 3, 4, 5].sum(), 15, "[1, 2, 3, 4, 5] sums to 15"
+
+test "#eachSlice", 6, ->
+  [1, 2, 3, 4, 5, 6].eachSlice 2, (array) ->
+    equals array[0] % 2, 1
+    equals array[1] % 2, 0
+
+test "#without", ->
+  array = [1, 2, 3, 4]
+
+  excluded = array.without([2, 4])
+
+  equals excluded[0], 1
+  equals excluded[1], 3
+
+test "#clear", ->
+  array = [1, 2, 3, 4]
+
+  equals array.length, 4
+  equals array[0], 1
+
+  array.clear()
+
+  equals array.length, 0
+  equals array[0], undefined
+
+test "#wrap", ->
+  array = [0, 1, 2, 3, 4]
+
+  equals array.wrap(0), 0
+  equals array.wrap(-1), 4
+  equals array.wrap(2), 2
+
+test "#zip", ->
+  a = [1, 2, 3]
+  b = [4, 5, 6]
+  c = [7, 8]
+
+  output = a.zip(b, c)
+
+  equals output[0][0], 1
+  equals output[0][1], 4
+  equals output[0][2], 7
+
+  equals output[2][2], undefined
+
+module undefined

data/source/javascripts/_test/bindable.coffee

@@ -0,0 +1,68 @@
+module "Bindable"
+
+test "#bind and #trigger", 1, ->
+  o = Core().include("Bindable")
+
+  o.bind("test", -> ok true)
+
+  o.trigger("test")
+
+test "Multiple bindings", 2, ->
+  o = Core().include(Bindable)
+
+  o.bind("test", -> ok true)
+  o.bind("test", -> ok true)
+
+  o.trigger("test")
+
+test "#trigger arguments", ->
+  o = Core().include(Bindable)
+
+  param1 = "the message"
+  param2 = 3
+
+  o.bind "test", (p1, p2) ->
+    equal(p1, param1)
+    equal(p2, param2)
+
+  o.trigger "test", param1, param2
+
+test "#unbind", ->
+  o = Core().include("Bindable")
+
+  callback = ->
+    ok false
+
+  o.bind "test", callback
+  # Unbind specific event
+  o.unbind "test", callback
+  o.trigger "test"
+
+  o.bind "test", callback
+  # Unbind all events
+  o.unbind "test"
+  o.trigger "test"
+  
+test "#trigger namespace", 1, ->
+  o = Core().include("Bindable")
+  o.bind "test.TestNamespace", ->
+    ok true
+
+  o.trigger "test"
+
+  o.unbind ".TestNamespace"
+  o.trigger "test"
+  
+test "#unbind namespaced", 1, ->
+  o = Core().include("Bindable")
+  
+  o.bind "test.TestNamespace", ->
+    ok true
+
+  o.trigger "test"
+
+  o.unbind ".TestNamespace", ->
+  o.trigger "test"
+
+module()
+

data/source/javascripts/_test/command_stack.coffee

@@ -0,0 +1,99 @@
+module "CommandStack"
+
+test "undo on an empty stack returns undefined", ->
+  commandStack = CommandStack()
+
+  equals commandStack.undo(), undefined
+
+test "redo on an empty stack returns undefined", ->
+  commandStack = CommandStack()
+
+  equals commandStack.redo(), undefined
+
+test "executes commands", 1, ->
+  command =
+    execute: ->
+      ok true, "command executed"
+
+  commandStack = CommandStack()
+
+  commandStack.execute command
+
+test "can undo", 1, ->
+  command =
+    execute: ->
+    undo: ->
+      ok true, "command executed"
+
+  commandStack = CommandStack()
+  commandStack.execute command
+
+  commandStack.undo()
+
+test "can redo", 2, ->
+  command =
+    execute: ->
+      ok true, "command executed"
+    undo: ->
+
+  commandStack = CommandStack()
+  commandStack.execute command
+
+  commandStack.undo()
+  commandStack.redo()
+
+test "executes redone command once on redo", 4, ->
+  command =
+    execute: ->
+      ok true, "command executed"
+    undo: ->
+
+  commandStack = CommandStack()
+  commandStack.execute command
+
+  commandStack.undo()
+  commandStack.redo()
+
+  equals commandStack.redo(), undefined
+  equals commandStack.redo(), undefined
+
+test "command is returned when undone", ->
+  command =
+    execute: ->
+    undo: ->
+
+  commandStack = CommandStack()
+  commandStack.execute command
+
+  equals commandStack.undo(), command, "Undone command is returned"
+
+test "command is returned when redone", ->
+  command =
+    execute: ->
+    undo: ->
+
+  commandStack = CommandStack()
+  commandStack.execute command
+  commandStack.undo()
+
+  equals commandStack.redo(), command, "Redone command is returned"
+
+test "cannot redo an obsolete future", ->
+  Command = ->
+    execute: ->
+    undo: ->
+
+  commandStack = CommandStack()
+  commandStack.execute Command()
+  commandStack.execute Command()
+
+  commandStack.undo()
+  commandStack.undo()
+
+  equals commandStack.canRedo(), true
+
+  commandStack.execute Command()
+
+  equals commandStack.canRedo(), false
+
+module()

data/source/javascripts/_test/core_object.coffee

@@ -0,0 +1,95 @@
+module "Core"
+
+test "#extend", ->
+  o = Core()
+
+  o.extend
+    test: "jawsome"
+
+  equals o.test, "jawsome"
+
+test "#attrAccessor", ->
+  o = Core
+    test: "my_val"
+
+  o.attrAccessor("test")
+
+  equals o.test(), "my_val"
+  equals o.test("new_val"), o
+  equals o.test(), "new_val"
+
+test "#attrReader", ->
+  o = Core
+    test: "my_val"
+
+  o.attrReader("test")
+
+  equals o.test(), "my_val"
+  equals o.test("new_val"), "my_val"
+  equals o.test(), "my_val"
+
+test "#include", ->
+  o = Core
+    test: "my_val"
+
+  M = (I, self) ->
+    self.attrReader "test"
+
+    test2: "cool"
+
+  ret = o.include M
+
+  equals ret, o, "Should return self"
+
+  equals o.test(), "my_val"
+  equals o.test2, "cool"
+  
+test "#include same module twice", 1, ->
+  window.M = (I, self) ->
+    ok(true)
+    
+    test: true
+    
+  o = Core()
+
+  o.include(M)
+  o.include(M)
+
+test "#include multiple", ->
+  o = Core
+    test: "my_val"
+
+  M = (I, self) ->
+    self.attrReader "test"
+
+    test2: "cool"
+    
+  M2 = (I, self) ->
+    test2: "coolio"
+
+  o.include M, M2
+  
+  equals o.test2, "coolio"
+  
+test "#include string", ->
+  window.TestM = (I, self) ->
+    self.attrReader "test"
+
+    test2: "cool"
+
+  o = Core
+    test: "my_val"
+
+  o.include "TestM"
+
+  equals o.test(), "my_val"
+  
+test "#send", ->
+  o = Core
+    test: true
+
+  o.send("attrAccessor", "test")
+
+  ok(o.test())
+
+module undefined