admin_data 1.0.0

data/lib/js/validate_model/select_all.js

@@ -0,0 +1,15 @@
+jQuery(document).ready(function($) {
+	return function($) {
+
+		$('input#validate_model_select_all').click(function() {
+			if ($(this).attr('checked')) {
+				$("input[type=checkbox]").attr("checked", true);
+			} else {
+				$("input[type=checkbox]").attr("checked", false);
+			}
+		});
+
+	};
+} (jQuery));
+
+

data/lib/js/vendor/jack.js

@@ -0,0 +1,903 @@
+/**
+ *
+ *  JACK :: JavaScript Mocking.
+ *  Version: $Id$
+ *
+ */
+
+
+function jack() {} // This needs to be here to make error reporting work correctly in IE.
+
+(function (){ // START HIDING FROM GLOBAL SCOPE
+	/** EXPORT JACK **/
+	window.jack = new Jack();
+	window.jack.matchers = new Matchers();
+	window.jack.util = new Util();
+	window.jack.FunctionSpecification = FunctionSpecification;
+	window.jack.FunctionGrab = FunctionGrab;
+	return;
+
+
+	/**
+	 * Constructor for object that will be exposed as the global jack
+	 */
+	function Jack() {
+		var functionGrabs = {};
+		var objectGrabs = {};
+		var environment = new Environment();
+		var reportMessages = [];
+		var currentExpectation = null;
+		var publicApi = createPublicApi();
+		return publicApi;
+
+		function createPublicApi() {
+			var api = jackFunction;
+			api.grab = grab;
+			api.create = create;
+			api.inspect = inspect;
+			api.expect = expect;
+			api.verify = verify;
+			api.report = report;
+			api.reportAll = reportAll;
+			api.env = environment;
+			return api;
+		}
+		function jackFunction(delegate) {
+			before();
+			firstPass(delegate);
+			// secondPass(delegate);
+			after();
+		}
+		function before() {
+			functionGrabs = {};
+			objectGrabs = {};
+			environment.reset();
+		}
+		function firstPass(delegate) {
+			delegate();
+		}
+		function secondPass(delegate) {
+			var oldExpect = publicApi.expect;
+			publicApi.expect = function(name) {
+				var fakeEx = {};
+				var grab = findGrab(name);
+				if(grab._beenThroughSecondPass) {
+					var ex = grab.expect();
+					for(prop in ex) {
+						if(typeof ex[prop] == "function") {
+							fakeEx[prop] = function() { return fakeEx; }
+						}
+					}
+				}
+				grab._beenThroughSecondPass = true;
+				return fakeEx;
+			};
+			var findMore = true;
+			for(var i=0; findMore && i<10; i++) {
+				try {
+					delegate();
+					findMore = false;
+				} catch(exception) {
+					var line = -1;
+					if(exception.lineNumber != null) {
+						line = exception.lineNumber;
+					} else if(exception['opera#sourceloc'] != null) {
+						line = exception['opera#sourceloc'];
+					}
+					currentExpectation._lineNumber = line;
+				}
+			}
+			publicApi.expect = oldExpect;
+		}
+		function after() {
+			var reports = getTextReports();
+			resetGrabs();
+			if(reports.length > 0) {
+				environment.report(reports[0]);
+			}
+		}
+		function getTextReports() {
+			var failedReports = [];
+			for(var name in functionGrabs) {
+				var reports = functionGrabs[name].reportAll(name);
+				for(var i=0; i<reports.length; i++) {
+					if(reports[i].fail) {
+						failedReports.push(reports[i].message);
+					}
+				}
+			}
+			for(var name in objectGrabs) {
+				var reports = objectGrabs[name].report(name);
+				for(var i=0; i<reports.length; i++) {
+					if(reports[i].fail) {
+						failedReports.push(reports[i].message);
+					}
+				}
+			}
+			return failedReports;
+		}
+		function grab() {
+			if("object" == typeof arguments[0] && "string" == typeof arguments[1]) {
+				var parentObject = arguments[0];
+				var name = arguments[1];
+				var fullName = "[local]." + name;
+				return grabFunction(fullName, parentObject[name], parentObject);
+			} else {
+				var grabbed = null;
+				eval("grabbed = " + arguments[0]);
+				if("function" == typeof grabbed) {
+					var functionGrab = grabFunction(arguments[0], grabbed);
+					eval("grabbed = " + arguments[0]);
+					grabObject(arguments[0], grabbed);
+					return functionGrab;
+				} else if("object" == typeof grabbed) {
+					return grabObject(arguments[0], grabbed);
+				}
+				return null;
+			}
+		}
+		function grabFunction(fullName, grabbed, parentObject) {
+			if(parentObject == null) {
+				parentObject = window;
+			}
+			var functionName = fullName;
+			var nameParts = fullName.split(".");
+			if(nameParts[0] == "[local]") {
+				functionName = nameParts[1];
+			} else if(nameParts.length > 1) {
+				functionName = nameParts.pop();
+				if(parentObject == window) {
+					var parentName = nameParts.join(".");
+					eval("parentObject = " + parentName);
+				}
+			}
+			functionGrabs[fullName] = new FunctionGrab(functionName, grabbed, parentObject);
+			return functionGrabs[fullName];
+		}
+		function grabObject(name, grabbed) {
+			objectGrabs[name] = new ObjectGrab(name, grabbed);
+			return objectGrabs[name];
+		}
+		function create(objectName, functionNames) {
+			var mockObject = {};
+			for(var i=0; i<functionNames.length; i++) {
+				mockObject[functionNames[i]] = function() {};
+				var fullName = objectName+"."+functionNames[i];
+				grabFunction(fullName, mockObject[functionNames[i]], mockObject);
+			}
+			return mockObject;
+		}
+		function inspect(name) {
+			return findGrab(name);
+		}
+		function expect(name) {
+			if(findGrab(name) == null) {
+				grab(name);
+			}
+			currentExpectation = findGrab(name).expect().once();
+			return currentExpectation;
+		}
+		function verify(name) {
+			if(findGrab(name) == null) {
+				grab(name);
+			}
+			currentExpectation = findGrab(name).expect().once();
+			return currentExpectation;
+		}
+		function report(name, expectation) {
+			return findGrab(name).report(expectation, name);
+		}
+		function reportAll(name) {
+			return findGrab(name).reportAll(name);
+		}
+		function findGrab(name) {
+			var parts = name.split(".");
+			if(parts.length == 1 && functionGrabs[name] != null) {
+				return functionGrabs[name];
+			} else if(parts.length == 1 && objectGrabs[name] != null) {
+				return objectGrabs[name];
+			} else {
+				if(functionGrabs[name] != null) {
+					return functionGrabs[name];
+				}
+				if(objectGrabs[name] != null) {
+					return objectGrabs[name];
+				}
+				if(objectGrabs[parts[0]] != null) {
+					return objectGrabs[parts[0]].examine(parts[1]);
+				}
+				return undefined;
+			}
+		}
+		function resetGrabs() {
+			for(var g in functionGrabs) {
+				functionGrabs[g].reset();
+			}
+			for(var g in objectGrabs) {
+				objectGrabs[g].reset();
+			}
+		}
+	} // END Jack()
+
+
+	/**
+	 * @functionName      Name of grabbed function
+	 * @grabbedFunction   Reference to grabbed function
+	 * @parentObject      The object the function was grabbed from
+	 */
+	function FunctionGrab(functionName, grabbedFunction, parentObject) {
+		var invocations = [];
+		var specifications = [];
+		var emptyFunction = function(){};
+
+		init();
+		return {
+			'times': function() { return invocations.length; },
+			'reset': reset,
+			'expect': expect,
+			'specify': specify,
+			'report': report,
+			'reportAll': reportAll,
+			'mock': mock,
+			'stub': stub,
+			'arguments': getArguments,
+			'name': function() { return functionName }
+		};
+
+		function init() {
+			var original = parentObject[functionName];
+			var handler = function() {
+				return handleInvocation.apply(this,arguments);
+			}
+			for(var prop in original) {
+				handler[prop] = original[prop];
+			}
+			parentObject[functionName] = handler;
+		}
+		function handleInvocation() {
+			var invocation = new FunctionSpecification();
+			for(var i=0; i<arguments.length; i++) {
+				invocation.whereArgument(i).is(arguments[i]);
+			}
+			invocations.push(invocation);
+			var specification = findSpecificationFor(invocation);
+			if(specification == null) {
+				return grabbedFunction.apply(this, arguments);
+			} else if(specification.hasMockImplementation()) {
+				return specification.invoke.apply(this, arguments);
+			} else {
+				specification.invoke.apply(this, arguments);
+				return grabbedFunction.apply(this, arguments);
+			}
+		}
+		function matchInvocationsToSpecifications() {
+			for(var i=0; i<invocations.length; i++) {
+				var spec = findSpecificationFor(invocations[i]);
+				if(spec != null) {
+
+				}
+			}
+		}
+		function findSpecificationFor(invocation) {
+			for(var i=0; i<specifications.length; i++) {
+				var specification = specifications[i];
+				if(invocation.satisfies(specification)) {
+					return specification;
+				}
+			}
+			return null;
+		}
+		function isArgumentContstraintsMatching(invocation, expectation) {
+			var constr = expectation._argumentConstraints;
+			var arg = invocation.arguments;
+			if(constr == null) {
+				return true;
+			} else if(constr.length != arg.length) {
+				return false;
+			} else {
+				for(var i=0; i<constr.length; i++) {
+					if(!constr[i]) { continue; }
+					for(var j=0; j<constr[i].length; j++) {
+						if(typeof constr[i][j] == "function" && !constr[i][j](arg[i])) {
+							return false;
+						}
+					}
+				}
+				return true;
+			}
+		}
+		function reset() {
+			parentObject[functionName] = grabbedFunction;
+		}
+		function specify() {
+			var spec = new FunctionSpecification();
+			spec._id = specifications.length;
+			specifications.push(spec);
+			return spec;
+		}
+		function verify() {
+
+		}
+		function expect() {
+			return specify();
+		}
+		function mock(implementation) {
+			return expect().mock(implementation);
+		}
+		function stub() {
+			return expect();
+		}
+		function parseTimes(expression) {
+			var result = 0;
+			if("number" == typeof expression) {
+				result = expression;
+			} else if("string" == typeof expression) {
+				var parts = expression.split(" ");
+				result = parseInt(parts[0]);
+			}
+			return result;
+		}
+		function reportAll(fullName) {
+			var reports = [];
+			for(var i=0; i<specifications.length; i++) {
+				reports.push(report(specifications[i], fullName));
+			}
+			return reports;
+		}
+		function report(specification, fullName) {
+			if(specification == null) {
+				if(specifications.length == 0) {
+					var spec = specify().never();
+					for(var i=0; i<invocations.length; i++) {
+						spec.invoke();
+					}
+				}
+				specification = specifications[0];
+			}
+			var report = {};
+			report.expected = specification.invocations().expected;
+			report.actual = specification.invocations().actual;
+			report.success = specification.testTimes(report.actual);
+			report.fail = !report.success;
+			if(report.fail) {
+				report.message = "Expectation failed: " + specification.describe(fullName);
+			}
+			return report;
+		}
+		function generateReportMessage(report, fullName, argumentsDisplay) {
+			return report.messageParts.template
+					.replace("{name}",fullName)
+					.replace("{arguments}",argumentsDisplay)
+					.replace("{quantifier}",report.messageParts.quantifier)
+					.replace("{expected}",report.expected)
+					.replace("{actual}",report.actual);
+		}
+		function getArgumentsDisplay(expectation) {
+			if(expectation == null) {
+				return "";
+			}
+			var displayValues = [];
+			var constraints = expectation._argumentConstraints;
+			if(constraints == null) {
+				return "";
+			} else {
+				for(var i=0; i<constraints.length; i++) {
+					if(constraints[i] != null) {
+						displayValues.push(constraints[i][0].display);
+					} else {
+						displayValues.push('[any]');
+					}
+				}
+				return displayValues.join(', ');
+			}
+		}
+		function getArguments() {
+			return invocations[0].getArgumentValues();
+		}
+	} // END FunctionGrab()
+
+
+	/**
+	 *
+	 */
+	function ObjectGrab(objectName, grabbedObject) {
+		var grabs = {};
+
+		init();
+		return {
+			'examine': getGrab,
+			'report': report,
+			'getGrab': getGrab,
+			'getGrabs': function() {  return grabs },
+			'reset': reset
+		};
+
+		function init() {
+			for(key in grabbedObject) {
+				var property =  grabbedObject[key];
+				if("function" == typeof property) {
+					grabs[key] = new FunctionGrab(key, property, grabbedObject);
+				}
+			}
+		}
+		function report(name) {
+			var allReports = [];
+			for(var g in grabs) {
+				var reports = grabs[g].reportAll(name+"."+grabs[g].name());
+				for(var i=0; i<reports.length; i++) {
+					allReports.push(reports[i]);
+				}
+			}
+			return allReports;
+		}
+		function getGrab(name) {
+			return grabs[name];
+		}
+		function reset() {
+			for(var g in grabs) {
+				grabs[g].reset();
+			}
+		}
+	}
+
+
+	/**
+	 *
+	 */
+	function Environment() {
+		var reportingEnabled = true;
+		init();
+		return {
+			'isJSSpec': isJSSpec,
+			'isScriptaculous': isScriptaculous,
+			'isQunit': isQunit,
+			'isJsTestDriver': isJsTestDriver,
+			'isYuiTest': isYuiTest,
+			'report': report,
+			'disableReporting': function() { reportingEnabled = false; },
+			'enableReporting': function() { reportingEnabled = true; },
+			'reset': function() {}
+		}
+		function init() {
+
+		}
+		function isJSSpec() {
+			return window.JSSpec != null;
+		}
+		function isScriptaculous() {
+			return window.Test != null && window.Test.Unit != null && window.Test.Unit.Runner != null;
+		}
+		function isQunit() {
+			return window.QUnit != null;
+		}
+		function isJsTestDriver() {
+			return window.jstestdriver != null;
+		}
+		function isYuiTest() {
+			var y = window.YAHOO;
+			return y != null && y.tool != null && y.tool.TestCase != null;
+		}
+		function report(message) {
+			if(!reportingEnabled) { return; }
+			if(isYuiTest()) {
+				YAHOO.util.Assert.fail(message);
+			} else if(isJsTestDriver()) {
+				fail(message);
+			} else if(isScriptaculous()) {
+				throw new Error(message);
+			} else if(isQunit()) {
+				ok(false, message);
+			} else if(isJSSpec()) {
+				throw new Error(message);
+			}
+		}
+	}
+
+	/**
+	 *
+	 */
+	function Util() {
+		return {
+			'displayValue': displayValue
+		}
+
+		function displayValue() {
+			var value = arguments[0];
+			var prefix = "";
+			if(arguments.length > 1) {
+				value = arguments[1];
+				prefix = arguments[0];
+			}
+			if(value == undefined) {
+				return displayValueNullOrUndefined(value);
+			}
+			var display = displayValueDefault(value);
+			if('string' == typeof value) {
+				display = displayValueString(value);
+			} else if(value.constructor == Array) {
+				display = displayValueArray(value);
+			} else if(value.constructor == RegExp) {
+				display = displayValueRegExp(value);
+			} else if('object' == typeof value) {
+				display = displayValueObject(value);
+			}
+			return prefix + display;
+		}
+		function displayValueDefault(value) {
+			return value.toString();
+		}
+		function displayValueString(value) {
+			return "'" + value + "'";
+		}
+		function displayValueArray(value) {
+			var displayValues = [];
+			for(var i=0; i<value.length; i++) {
+				displayValues.push(displayValue(value[i]));
+			}
+			return "[" + displayValues.join(",") + "]";
+		}
+		function displayValueNullOrUndefined(value) {
+			if(value === undefined) {
+				return "undefined";
+			} else if(value === null) {
+				return "null";
+			}
+		}
+		function displayValueRegExp(value) {
+			return value.toString();
+		}
+		function displayValueObject(value) {
+			var keyValues = [];
+			for(var p in value) {
+				keyValues.push(p + ':' + displayValue(value[p]));
+			}
+			return '{' + keyValues.join(',') + '}';
+		}
+	}
+
+	/**
+	 *
+	 */
+	function FunctionSpecification() {
+		var constraints = null;
+		var argumentValues = [];
+		var mockImplementation = null;
+		var timing = {actual: 0, expected: 1, modifier: 0};
+
+		var api = createApi();
+		return api;
+
+		function createApi() {
+			var api = {};
+			mixinMatchers(api);
+			mixinTiming(api);
+			api.test = test;
+			api.testTimes = testTimes;
+			api.satisfies = satisfies;
+			api.invoke = invoke;
+			api.mock = mock;
+			api.stub = stub;
+			api.returnValue = returnValue;
+			api.returnValues = returnValues;
+			api.describe = describe;
+			api.invocations = invocations;
+			api.getArgumentValues = getArgumentValues;
+			api.hasMockImplementation = hasMockImplementation;
+			return api;
+		}
+		function mixinMatchers(api) {
+			api.whereArgument = function(argIndex) {
+				var collected = {};
+				for(var name in jack.matchers) {
+					addMatcher(argIndex, name, collected)
+				}
+				return collected;
+			}
+			api.withArguments = function() {
+				for(var i=0; i<arguments.length; i++) {
+					api.whereArgument(i).is(arguments[i]);
+				}
+				return api;
+			}
+			api.withNoArguments = function() { constraints = []; return api; }
+			return api;
+
+			function addMatcher(argIndex, name, collection) {
+				collection[name] = function() {
+					addConstraint(argIndex, jack.matchers[name], arguments);
+					if(name == "is") {
+						addArgumentValue(argIndex, arguments[0]);
+					}
+					return api;
+				}
+			}
+		}
+		function mixinTiming(api) {
+			api.exactly = function(times) {
+				timing.expected = parseTimes(times);
+				return api;
+			}
+			api.once = function() {
+				timing.expected = 1;
+				return api;
+			}
+			api.atLeast = function(times) {
+				timing.expected = parseTimes(times);
+				timing.modifier = 1;
+				return api;
+			}
+			api.atMost = function(times) {
+				timing.expected = parseTimes(times);
+				timing.modifier = -1;
+				return api;
+			}
+			api.never = function() {
+				timing.expected = 0;
+				return api;
+			}
+
+			function parseTimes(times) {
+				return parseInt(times);
+			}
+		}
+		function addArgumentValue(index, value) {
+			argumentValues[index] = value;
+		}
+		function addConstraint(argIndex, matcher, matcherArguments) {
+			createConstraintsArrayIfNull(argIndex);
+			var constraint = function(value) {
+				var allArguments = [value];
+				for(var i=0; i<matcherArguments.length; i++) {
+					allArguments.push(matcherArguments[i]);
+				}
+				var test = matcher.apply(null, allArguments);
+				return test.result;
+			}
+			constraints[argIndex].push(constraint);
+			constraints[argIndex].describe = function() {
+				var allArguments = [""];
+				for(var i=0; i<matcherArguments.length; i++) {
+					allArguments.push(matcherArguments[i]);
+				}
+				return matcher.apply(null, allArguments).expected;
+			}
+		}
+		function createConstraintsArrayIfNull(argIndex) {
+			if(constraints == null) {
+				constraints = [];
+			}
+			if(constraints[argIndex] == null) {
+				constraints[argIndex] = [];
+			}
+		}
+		function test() {
+			var result = true;
+			if(constraints != null) {
+				if(constraints.length != arguments.length) {
+					result = false;
+				} else {
+					for (var i = 0; i < constraints.length; i++) {
+						var oneArgumentsConstraints = constraints[i];
+						if (oneArgumentsConstraints != null) {
+							for (var j = 0; j < oneArgumentsConstraints.length; j++) {
+								var constraint = oneArgumentsConstraints[j];
+								if (constraint && !constraint(arguments[i])) {
+									result = false;
+								}
+							}
+						}
+					}
+				}
+			}
+			return result;
+		}
+		function testTimes(times) {
+			if(timing.modifier == 0) {
+				return times == timing.expected;
+			} else if(timing.modifier == 1) {
+				return times >= timing.expected;
+			} else if(timing.modifier == -1) {
+				return times <= timing.expected;
+			}
+		}
+		function satisfies(other) {
+			return other.test.apply(this, argumentValues);
+		}
+		function invoke() {
+			timing.actual++;
+			if(mockImplementation != null) {
+				return mockImplementation.apply(this, arguments);
+			}
+		}
+		function mock(implementation) {
+			mockImplementation = implementation;
+			return api;
+		}
+		function stub() {
+			mockImplementation = function() {};
+			return api;
+		}
+		function returnValue(value) {
+			mockImplementation = function() {
+				return value;
+			}
+		}
+		function returnValues() {
+			var values = [], orig = this;
+			for (var i = 0, len = arguments.length; i < len; i++) { values.push(arguments[i]); }
+			mockImplementation = function() {
+				return values.shift();
+			};
+		}
+		function hasMockImplementation() {
+			return mockImplementation != null;
+		}
+		function invocations() {
+			return {
+				actual: timing.actual,
+				expected: timing.expected
+			};
+		}
+		function getArgumentValues() {
+			return argumentValues;
+		}
+		function describe(name) {
+			return name +"(" + describeConstraints() + ") " + describeTimes();
+		}
+		function describeConstraints() {
+			if(constraints == null) {
+				return "";
+			}
+			var descriptions = [];
+			for(var i=0; i<constraints.length; i++) {
+				if(constraints[i] != null) {
+					descriptions.push(constraints[i].describe());
+				} else {
+					descriptions.push("[any]");
+				}
+			}
+			return descriptions.join(", ");
+		}
+		function describeTimes() {
+			var description = timing.expected;
+			if(timing.expected == 1) {
+				description += " time";
+			} else {
+				description += " times";
+			}
+			if(timing.modifier == 0) {
+				description = "expected exactly " + description;
+			} else if(timing.modifier > 0) {
+				description = "expected at least " + description;
+			} else if(timing.modifier < 0) {
+				description = "expected at most " + description;
+			}
+			description += ", called " + timing.actual + " time";
+			if(timing.actual != 1) {
+				description += "s";
+			}
+			return description;
+		}
+	}
+
+
+	/**
+	 *
+	 */
+	function Matchers() {
+		return {
+			'is':
+				function(a, b) {
+					return result(a==b, a, '', b);
+				},
+			'isNot':
+				function(a, b) {
+					return result(a!=b, a, 'not:', b);
+				},
+			'isType':
+				function(a, b) {
+					return result(b == typeof a, a, 'type:', b);
+				},
+			'matches':
+				function(a, b) {
+					return result(b.test(a), a, 'matching:', b)
+				},
+			'hasProperty':
+				function(a, b, c) {
+					var match = c ? a[b]==c : a[b]!=undefined;
+					var bDisplay = b;
+					if(c != null) {
+						bDisplay = {};
+						bDisplay[b] = c;
+					}
+					return result(match, a, 'property:', bDisplay)
+				},
+			'hasProperties':
+				function(a, b) {
+					var match = true;
+					for(var p in b) {
+						if(a[p] != b[p]) {
+							match = false;
+						}
+					}
+					return result(match, a, 'properties:', b);
+				},
+			'isGreaterThan':
+				function(a, b) {
+					return result(b < a, a, '>', b);
+				},
+			'isLessThan':
+				function(a, b) {
+					return result(b > a, a, '<', b);
+				},
+			'isOneOf':
+				function() {
+					var a = arguments[0];
+					var b = [];
+					for(var i=1; i<arguments.length; i++) {
+						b.push(arguments[i]);
+					}
+					var match = false;
+					for(var i=0; i<b.length; i++) {
+						if(b[i] == a) {
+							match = true;
+						}
+					}
+					return result(match, a, 'oneOf:', b);
+				}
+		}
+
+		function result(match, actual, prefix, expected) {
+			return {
+				result: match,
+				actual: jack.util.displayValue(actual),
+				expected: jack.util.displayValue(prefix, expected)
+			}
+		}
+	}
+
+})(); // END HIDING FROM GLOBAL SCOPE
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+