RubyGems - cssesc-source - Versions diffs - 0.1.0 - Mend

cssesc-source 0.1.0

Files changed (908) hide show

data/vendor/node_modules/qunitjs/addons/junitlogger/README.md ADDED Viewed

@@ -0,0 +1,18 @@
+JUnit Logger - A QUnit addon for producing JUnit-style XML test reports
+============
+A QUnit addon that produces JUnit-style XML test reports for integration into build tools like Jenkins.
+### Usage ###
+Include the addon script after QUnit itself, then implement the `jUnitReport` hook to do something with the XML string (e.g. upload it to a server):
+```js
+QUnit.jUnitReport = function(report) {
+	console.log(report.xml);
+};
+```
+### Notes ###
+If you're using Grunt, you should take a look at its [qunit task](https://github.com/cowboy/grunt/blob/master/docs/task_qunit.md). Or use [John Bender's grunt-junit plugin](https://github.com/johnbender/grunt-junit) to have the `qunit` task output JUnit-style XML, as this reporter does.

data/vendor/node_modules/qunitjs/addons/junitlogger/index.html ADDED Viewed

@@ -0,0 +1,44 @@
+<!DOCTYPE html>
+<html>
+<head>
+	<meta charset="UTF-8">
+	<title>QUnit Test Suite - JUnit report</title>
+	<link rel="stylesheet" href="../../qunit/qunit.css">
+	<script src="../../qunit/qunit.js"></script>
+	<script src="junitlogger.js"></script>
+	<script>
+	QUnit.jUnitReport = function(data) {
+		console.log(data.xml);
+	};
+	module('Module 1');
+	test("test 1", 2, function () {
+		equal(1, 1, "Assert 1 = 1");
+		equal(1, 2, "Assert fail 1 = 2");
+	});
+	test("test 2", 3, function () {
+		equal(1, 1, "Assert 1 = 1");
+		equal(1, 2, "Assert fail 1 = 2");
+		equal(1, 1, "Assert 1 = 1");
+	});
+	module('Module 2');
+	test("test 3", 2, function () {
+		equal(1, 1, "Assert 1 = 1");
+		equal(1, 2, "Assert fail 1 = 2");
+	});
+	test("test 4", 3, function () {
+		equal(1, 1, "Assert 1 = 1");
+		equal(1, 2, "Assert fail 1 = 2");
+		equal(1, 3, "Assert fail 1 = 3");
+	});
+	</script>
+</head>
+<body>
+	<div id="qunit"></div>
+</body>
+</html>

data/vendor/node_modules/qunitjs/addons/junitlogger/junitlogger.js ADDED Viewed

@@ -0,0 +1,306 @@
+(function() {
+	'use strict';
+	var currentRun, currentModule, currentTest, assertCount;
+	// Gets called when a report is generated.
+	QUnit.jUnitReport = function(/* data */) {
+		// Override me!
+	};
+	QUnit.begin(function() {
+		currentRun = {
+			modules: [],
+			total: 0,
+			passed: 0,
+			failed: 0,
+			start: new Date(),
+			time: 0
+		};
+	});
+	QUnit.moduleStart(function(data) {
+		currentModule = {
+			name: data.name,
+			tests: [],
+			total: 0,
+			passed: 0,
+			failed: 0,
+			start: new Date(),
+			time: 0,
+			stdout: [],
+			stderr: []
+		};
+		currentRun.modules.push(currentModule);
+	});
+	QUnit.testStart(function(data) {
+		// Setup default module if no module was specified
+		if (!currentModule) {
+			currentModule = {
+				name: data.module || 'default',
+				tests: [],
+				total: 0,
+				passed: 0,
+				failed: 0,
+				start: new Date(),
+				time: 0,
+				stdout: [],
+				stderr: []
+			};
+			currentRun.modules.push(currentModule);
+		}
+		// Reset the assertion count
+		assertCount = 0;
+		currentTest = {
+			name: data.name,
+			failedAssertions: [],
+			total: 0,
+			passed: 0,
+			failed: 0,
+			start: new Date(),
+			time: 0
+		};
+		currentModule.tests.push(currentTest);
+	});
+	QUnit.log(function(data) {
+		assertCount++;
+		// Ignore passing assertions
+		if (!data.result) {
+			currentTest.failedAssertions.push(data);
+			// Add log message of failure to make it easier to find in Jenkins CI
+			currentModule.stdout.push('[' + currentModule.name + ', ' + currentTest.name + ', ' + assertCount + '] ' + data.message);
+		}
+	});
+	QUnit.testDone(function(data) {
+		currentTest.time = (new Date()).getTime() - currentTest.start.getTime();  // ms
+		currentTest.total = data.total;
+		currentTest.passed = data.passed;
+		currentTest.failed = data.failed;
+		currentTest = null;
+	});
+	QUnit.moduleDone(function(data) {
+		currentModule.time = (new Date()).getTime() - currentModule.start.getTime();  // ms
+		currentModule.total = data.total;
+		currentModule.passed = data.passed;
+		currentModule.failed = data.failed;
+		currentModule = null;
+	});
+	QUnit.done(function(data) {
+		currentRun.time = data.runtime || ((new Date()).getTime() - currentRun.start.getTime());  // ms
+		currentRun.total = data.total;
+		currentRun.passed = data.passed;
+		currentRun.failed = data.failed;
+		generateReport(data, currentRun);
+	});
+	var generateReport = function(results, run) {
+		var pad = function(n) {
+			return n < 10 ? '0' + n : n;
+		};
+		var toISODateString = function(d) {
+			return d.getUTCFullYear() + '-' +
+				pad(d.getUTCMonth() + 1)+'-' +
+				pad(d.getUTCDate()) + 'T' +
+				pad(d.getUTCHours()) + ':' +
+				pad(d.getUTCMinutes()) + ':' +
+				pad(d.getUTCSeconds()) + 'Z';
+		};
+		var convertMillisToSeconds = function(ms) {
+			return Math.round(ms * 1000) / 1000000;
+		};
+		var xmlEncode = function(text) {
+			var baseEntities = {
+				'"' : '&quot;',
+				"'" : '&apos;',
+				'<' : '&lt;',
+				'>' : '&gt;',
+				'&' : '&amp;'
+			};
+			return ('' + text).replace(/[<>&\"\']/g, function(chr) {
+				return baseEntities[chr] || chr;
+			});
+		};
+		var XmlWriter = function(settings) {
+			settings = settings || {};
+			var data = [], stack = [], lineBreakAt;
+			var addLineBreak = function(name) {
+				if (lineBreakAt[name] && data[data.length - 1] !== '\n') {
+					data.push('\n');
+				}
+			};
+			lineBreakAt = (function(items) {
+				var i, map = {};
+				items = items || [];
+				i = items.length;
+				while (i--) {
+					map[items[i]] = {};
+				}
+				return map;
+			})(settings.linebreak_at);
+			this.start = function(name, attrs, empty) {
+				if (!empty) {
+					stack.push(name);
+				}
+				data.push('<' + name);
+				for (var aname in attrs) {
+					data.push(' ' + xmlEncode(aname) + '="' + xmlEncode(attrs[aname]) + '"');
+				}
+				data.push(empty ? ' />' : '>');
+				addLineBreak(name);
+			};
+			this.end = function() {
+				var name = stack.pop();
+				addLineBreak(name);
+				data.push('</' + name + '>');
+				addLineBreak(name);
+			};
+			this.text = function(text) {
+				data.push(xmlEncode(text));
+			};
+			this.cdata = function(text) {
+				data.push('<![CDATA[' + text + ']]>');
+			};
+			this.comment = function(text) {
+				data.push('<!--' + text + '-->');
+			};
+			this.pi = function(name, text) {
+				data.push('<?' + name + (text ? ' ' + text : '') + '?>\n');
+			};
+			this.doctype = function(text) {
+				data.push('<!DOCTYPE' + text + '>\n');
+			};
+			this.getString = function() {
+				while (stack.length) {
+					this.end();  // internally calls `stack.pop();`
+				}
+				return data.join('').replace(/\n$/, '');
+			};
+			this.reset = function() {
+				data.length = 0;
+				stack.length = 0;
+			};
+			// Start by writing the XML declaration
+			this.pi(settings.xmldecl || 'xml version="1.0" encoding="UTF-8"');
+		};
+		// Generate JUnit XML report!
+		var m, mLen, module, t, tLen, test, a, aLen, assertion, isEmptyElement,
+			xmlWriter = new XmlWriter({
+				linebreak_at: ['testsuites', 'testsuite', 'testcase', 'failure', 'system-out', 'system-err']
+			});
+		xmlWriter.start('testsuites', {
+			hostname: 'localhost',
+			tests: run.total,
+			failures: run.failed,
+			errors: 0,
+			time: convertMillisToSeconds(run.time),  // ms → sec
+			timestamp: toISODateString(run.start)
+		});
+		for (m = 0, mLen = run.modules.length; m < mLen; m++) {
+			module = run.modules[m];
+			xmlWriter.start('testsuite', {
+				id: m,
+				name: module.name,
+				hostname: 'localhost',
+				tests: module.total,
+				failures: module.failed,
+				errors: 0,
+				time: convertMillisToSeconds(module.time),  // ms → sec
+				timestamp: toISODateString(module.start)
+			});
+			for (t = 0, tLen = module.tests.length; t < tLen; t++) {
+				test = module.tests[t];
+				xmlWriter.start('testcase', {
+					name: test.name,
+					tests: test.total,
+					failures: test.failed,
+					errors: 0,
+					time: convertMillisToSeconds(test.time),  // ms → sec
+					timestamp: toISODateString(test.start)
+				});
+				for (a = 0, aLen = test.failedAssertions.length; a < aLen; a++) {
+					assertion = test.failedAssertions[a];
+					isEmptyElement = assertion && !(assertion.actual && assertion.expected);
+					xmlWriter.start('failure', { type: 'AssertionFailedError', message: assertion.message }, isEmptyElement);
+					if (!isEmptyElement) {
+						xmlWriter.start('actual', { value: assertion.actual }, true);
+						xmlWriter.start('expected', { value: assertion.expected }, true);
+						xmlWriter.end();  //'failure'
+					}
+				}
+				xmlWriter.end();  //'testcase'
+			}
+			// Per-module stdout
+			if (module.stdout && module.stdout.length) {
+				xmlWriter.start('system-out');
+				xmlWriter.cdata('\n' + module.stdout.join('\n') + '\n');
+				xmlWriter.end();  //'system-out'
+			}
+			// Per-module stderr
+			if (module.stderr && module.stderr.length) {
+				xmlWriter.start('system-err');
+				xmlWriter.cdata('\n' + module.stderr.join('\n') + '\n');
+				xmlWriter.end();  //'system-err'
+			}
+			xmlWriter.end();  //'testsuite'
+		}
+		xmlWriter.end();  //'testsuites'
+		// Invoke the user-defined callback
+		QUnit.jUnitReport({
+			results: results,
+			xml: xmlWriter.getString()
+		});
+	};
+})();

data/vendor/node_modules/qunitjs/addons/phantomjs/README.md ADDED Viewed

@@ -0,0 +1,16 @@
+# PhantomJS Runner #
+A PhantomJS-powered headless test runner, providing basic console output for QUnit tests.
+### Usage ###
+```bash
+  phantomjs runner.js [url-of-your-qunit-testsuite]
+```
+### Example ###
+```bash
+  phantomjs runner.js http://localhost/qunit/test/index.html
+```
+### Notes ###
+ - Requires [PhantomJS](http://phantomjs.org/) 1.6+ (1.7+ recommended).
+ - If you're using Grunt, you should take a look at its [qunit task](https://github.com/gruntjs/grunt/blob/master/docs/task_qunit.md).

data/vendor/node_modules/qunitjs/addons/phantomjs/runner.js ADDED Viewed

@@ -0,0 +1,127 @@
+/*
+ * QtWebKit-powered headless test runner using PhantomJS
+ *
+ * PhantomJS binaries: http://phantomjs.org/download.html
+ * Requires PhantomJS 1.6+ (1.7+ recommended)
+ *
+ * Run with:
+ *   phantomjs runner.js [url-of-your-qunit-testsuite]
+ *
+ * e.g.
+ *   phantomjs runner.js http://localhost/qunit/test/index.html
+ */
+/*jshint latedef:false */
+/*global phantom:false, require:false, console:false, window:false, QUnit:false */
+(function() {
+	'use strict';
+	var args = require('system').args;
+	// arg[0]: scriptName, args[1...]: arguments
+	if (args.length !== 2) {
+		console.error('Usage:\n  phantomjs runner.js [url-of-your-qunit-testsuite]');
+		phantom.exit(1);
+	}
+	var url = args[1],
+		page = require('webpage').create();
+	// Route `console.log()` calls from within the Page context to the main Phantom context (i.e. current `this`)
+	page.onConsoleMessage = function(msg) {
+		console.log(msg);
+	};
+	page.onInitialized = function() {
+		page.evaluate(addLogging);
+	};
+	page.onCallback = function(message) {
+		var result,
+			failed;
+		if (message) {
+			if (message.name === 'QUnit.done') {
+				result = message.data;
+				failed = !result || result.failed;
+				phantom.exit(failed ? 1 : 0);
+			}
+		}
+	};
+	page.open(url, function(status) {
+		if (status !== 'success') {
+			console.error('Unable to access network: ' + status);
+			phantom.exit(1);
+		} else {
+			// Cannot do this verification with the 'DOMContentLoaded' handler because it
+			// will be too late to attach it if a page does not have any script tags.
+			var qunitMissing = page.evaluate(function() { return (typeof QUnit === 'undefined' || !QUnit); });
+			if (qunitMissing) {
+				console.error('The `QUnit` object is not present on this page.');
+				phantom.exit(1);
+			}
+			// Do nothing... the callback mechanism will handle everything!
+		}
+	});
+	function addLogging() {
+		window.document.addEventListener('DOMContentLoaded', function() {
+			var current_test_assertions = [];
+			QUnit.log(function(details) {
+				var response;
+				// Ignore passing assertions
+				if (details.result) {
+					return;
+				}
+				response = details.message || '';
+				if (typeof details.expected !== 'undefined') {
+					if (response) {
+						response += ', ';
+					}
+					response += 'expected: ' + details.expected + ', but was: ' + details.actual;
+					if (details.source) {
+						response += "\n" + details.source;
+					}
+				}
+				current_test_assertions.push('Failed assertion: ' + response);
+			});
+			QUnit.testDone(function(result) {
+				var i,
+					len,
+					name = result.module + ': ' + result.name;
+				if (result.failed) {
+					console.log('Test failed: ' + name);
+					for (i = 0, len = current_test_assertions.length; i < len; i++) {
+						console.log('    ' + current_test_assertions[i]);
+					}
+				}
+				current_test_assertions.length = 0;
+			});
+			QUnit.done(function(result) {
+				console.log('Took ' + result.runtime +  'ms to run ' + result.total + ' tests. ' + result.passed + ' passed, ' + result.failed + ' failed.');
+				if (typeof window.callPhantom === 'function') {
+					window.callPhantom({
+						'name': 'QUnit.done',
+						'data': result
+					});
+				}
+			});
+		}, false);
+	}
+})();