The Messy Notebook

// Assert methods needed by test framework
function assertTrue(boolean, errorMsg) {
    if (boolean === false) {
        throw (errorMsg);
    }
    return;
}
 
function assertFalse(boolean, errorMsg) {
    if (boolean === true) {
        throw (errorMsg);
    }
    return;
}

var Test = {
 
    runSuite: function() {
        // Call all methods/testcases in suite
        for (var testFunc in this.Suite) {
            if (this.Suite.hasOwnProperty(testFunc)) { // Don't call any inherited methods
                try {
                    this.Suite[testFunc]();
                }
                catch(err) {
                    alert(testFunc + "() failed: " + err);
                    return;
                }
            }
        }
 
        Graphics.drawString("--All tests in suite passed--", 400, 400);
    },
 
    Suite: {
 
        // Add test cases here
        testAsserts: function() {
            assertTrue(2 === 2, "This should never fail");
            assertFalse(2 === 3, "This should always fail");
        },
 
};

        testArrDimensions: function() {
            var width = 3;
            var height = 2;
            var initValue = "x";
            var arr = get2dArray(width, height, initValue);
 
            assertTrue(arr.getWidth() === width, "Width of array not expected length");
            assertTrue(arr.getHeight() === height, "Height of array not expected length");
 
            for (var x in arr) {
                if (arr.hasOwnProperty(x)) { // Don't call any inherited methods
                    assertTrue(arr[x].length === height, "Height of array not expected length");
                }
            }
        },
 
        testArrEach: function() {
            var arr = [2, 4, 5, 2];
            var length = arr.length;
 
            var elementsVisited = 0;
            arr.each(function(element) {
                assertTrue(element !== null, "Expected all elements to be non-null");
                elementsVisited++;
            });
 
            assertTrue(elementsVisited === length, "Didn't visit " + length + " elements as expected");
        },
 
        testArrEach2d: function() {
            var width = 3;
            var height = 2;
            var initValue = "x";
            var arr = get2dArray(width, height, initValue);
 
            var elementsVisited = 0;
            arr.each(function(element) {
                assertTrue(element === initValue, "Not all slots in array was set to " + initValue);
                elementsVisited++;
            });
 
            assertTrue(elementsVisited === (width * height), "Didn't visit " + (width * height) + " elements as expected");
        },
 
        testArrEachRow: function() {
            var width = 3;
            var height = 4;
            var initValue = "x";
            var arr = get2dArray(width, height, initValue);
 
            var rowsVisited = 0;
            arr.eachRowWithIndex(function(row) {
                assertTrue(row.length === width, "Expected row to be " + width + " elements long");
                rowsVisited++;
            });
 
            assertTrue(rowsVisited === height, "Didn't get " + height + " rows as expected");
        },
 
        testArrMap: function() {
            var width = 2;
            var height = 2;
            var initValue = "2";
            var arr = get2dArray(width, height, initValue);
 
            var mappedArr = arr.map(function(element) {
                return element * 2
            });
 
            var elementsVisited = 0
            mappedArr.each(function(element) {
                assertTrue(element === initValue * 2, "Not all slots in mapped array were transformed to new value");
                elementsVisited++;
            });
 
            assertTrue(elementsVisited === width * height, "Mapped array not same size as original array");
        }
 
    }

// Returns two dimensional array, every element initiated to given value
function get2dArray(width, height, initValue) {
    var arr2d = [];
 
    for (var x = 0; x < width; x++) { // For each row
        arr2d[x] = [];
    }
 
    for (x = 0; x < width; x++) {
        for (var y = 0; y < height; y++) {
            arr2d[x][y] = initValue;
        }
    }
 
    return arr2d;
}
 
// D. Crockford idiom for function mixin
Function.prototype.method = function(name, func) {
    this.prototype[name] = func;
    return this;
};
 
// Array mixins for 2d grid functionality
Array.method('getWidth',
function() {
    return this.length;
});
 
Array.method('getHeight',
function() {
    return this[0].length;
});
 
Array.method('isTwoDimensional',
function() {
    return (this[0].constructor == Array);
});
 
Array.method('each',
function(appliedFunction) {
    for (var x = 0; x < this.getWidth(); x++) {
        if (this.isTwoDimensional()) {
            for (var y = 0; y < this.getHeight(); y++) {
                appliedFunction(this[x][y]);
            }
        }
        else {
            appliedFunction(this[x]);
        }
    }
});
 
Array.method('eachWithIndexes',
function(appliedFunction) {
    for (var x = 0; x < this.getWidth(); x++) {
        if (this.isTwoDimensional()) {
 
            for (var y = 0; y < this.getHeight(); y++) {
                appliedFunction(this[x][y], x, y);
            }
        }
        else {
            appliedFunction(this[x], x);
        }
    }
});
 
Array.method('eachRowWithIndex',
function(appliedFunction) {
    for (rowCount = 0; rowCount < this.getHeight(); rowCount++) {
        var row = [];
        for (columnCount = 0; columnCount < this.getWidth(); columnCount++) {
            row[columnCount] = this[columnCount][rowCount];
        }
        appliedFunction(row, rowCount);
    }
});
 
Array.method('map',
function(appliedFunction) {
    var mappedArr = null;
    if (this.isTwoDimensional()) {
        mappedArr = get2dArray(this.getWidth(), this.getHeight(), null);
    }
    else {
        mappedArr = [];
    }
 
    for (var x = 0; x < this.getWidth(); x++) {
        if (this.isTwoDimensional()) {
            for (var y = 0; y < this.getHeight(); y++) {
                mappedArr[x][y] = appliedFunction(this[x][y], x, y);
            }
        }
        else {
            mappedArr[x] = appliedFunction(this[x]);
        }
    }
 
    return mappedArr;
});

desc "Run JSLint audit on code and markup"
task :jslint do
 
  lintCommand = "java -classpath ./lib/jsLint/js.jar "+
                  "org.mozilla.javascript.tools.shell.Main ./lib/jsLint/jslint.js";
 
  # Check the .html files in root dir
  lintTargets = Dir.entries(".").reject! do |direntry|
	  if(direntry !~ /(\.html)\z/ ) then
		 true
	  end
  end  
 
  lintTargets.each do |filename|
    echo "Running JSLint on: "+filename
    puts %x{ #{lintCommand} #{filename} };
  end
 
  # Check the .js files in /src dir
  lintTargets = Dir.entries("./src").reject! do |direntry|
	  if(direntry !~ /(\.js)\z/ ) then
		 true
	  end
  end
 
  lintTargets.each do |filename|
    echo "Running JSLint on: "+filename
    puts %x{ #{lintCommand} ./src/#{filename} };
  end
 
  echo "Done running JSLint"
 
end
 
def echo(msg)
  puts("  <Rake build>: "+msg);
end