q5 2.9.21 → 2.9.23

package/p5-tests/mocha.css

@@ -0,0 +1,289 @@
+@charset "utf-8";
+
+body {
+	margin: 0;
+	background-color: #111;
+	color: #fff;
+}
+
+#mocha {
+	font: 20px/1.5 "Helvetica Neue", Helvetica, Arial, sans-serif;
+	margin: 60px 50px;
+}
+
+#mocha ul,
+#mocha li {
+	margin: 0;
+	padding: 0;
+}
+
+#mocha ul {
+	list-style: none;
+}
+
+#mocha h1,
+#mocha h2 {
+	margin: 0;
+}
+
+#mocha h1 {
+	margin-top: 15px;
+	font-size: 1em;
+	font-weight: 200;
+}
+
+#mocha h1 a {
+	text-decoration: none;
+	color: inherit;
+}
+
+#mocha h1 a:hover {
+	text-decoration: underline;
+}
+
+#mocha .suite .suite h1 {
+	margin-top: 0;
+	font-size: .8em;
+}
+
+#mocha .hidden {
+	display: none;
+}
+
+#mocha h2 {
+	font-size: 12px;
+	font-weight: normal;
+	cursor: pointer;
+}
+
+#mocha .suite {
+	margin-left: 15px;
+}
+
+#mocha .test {
+	margin-left: 15px;
+	overflow: hidden;
+}
+
+#mocha .test.pending:hover h2::after {
+	content: '(pending)';
+	font-family: arial, sans-serif;
+}
+
+#mocha .test.pass.medium .duration {
+	background: #c09853;
+}
+
+#mocha .test.pass.slow .duration {
+	background: #b94a48;
+}
+
+#mocha .test.pass::before {
+	content: '✓';
+	font-size: 12px;
+	display: block;
+	float: left;
+	margin-right: 5px;
+	color: #00d6b2;
+}
+
+#mocha .test.pass .duration {
+	font-size: 9px;
+	margin-left: 5px;
+	padding: 2px 5px;
+	color: #fff;
+	-webkit-box-shadow: inset 0 1px 1px rgba(0, 0, 0, .2);
+	-moz-box-shadow: inset 0 1px 1px rgba(0, 0, 0, .2);
+	box-shadow: inset 0 1px 1px rgba(0, 0, 0, .2);
+	-webkit-border-radius: 5px;
+	-moz-border-radius: 5px;
+	-ms-border-radius: 5px;
+	-o-border-radius: 5px;
+	border-radius: 5px;
+}
+
+#mocha .test.pass.fast .duration {
+	display: none;
+}
+
+#mocha .test.pending {
+	color: #0b97c4;
+}
+
+#mocha .test.pending::before {
+	content: '◦';
+	color: #0b97c4;
+}
+
+#mocha .test.fail {
+	color: #c00;
+}
+
+#mocha .test.fail pre {
+	color: black;
+}
+
+#mocha .test.fail::before {
+	content: '✖';
+	font-size: 12px;
+	display: block;
+	float: left;
+	margin-right: 5px;
+	color: #c00;
+}
+
+#mocha .test pre.error {
+	color: #c00;
+	max-height: 300px;
+	overflow: auto;
+}
+
+/**
+ * (1): approximate for browsers not supporting calc
+ * (2): 42 = 2*15 + 2*10 + 2*1 (padding + margin + border)
+ *      ^^ seriously
+ */
+#mocha .test pre {
+	display: block;
+	float: left;
+	clear: left;
+	font: 12px/1.5 monaco, monospace;
+	margin: 5px;
+	padding: 15px;
+	border: 1px solid #eee;
+	max-width: 85%;
+	/*(1)*/
+	max-width: calc(100% - 42px);
+	/*(2)*/
+	word-wrap: break-word;
+	border-bottom-color: #ddd;
+	-webkit-border-radius: 3px;
+	-webkit-box-shadow: 0 1px 3px #eee;
+	-moz-border-radius: 3px;
+	-moz-box-shadow: 0 1px 3px #eee;
+	border-radius: 3px;
+}
+
+#mocha .test h2 {
+	position: relative;
+}
+
+#mocha .test a.replay {
+	position: absolute;
+	top: 3px;
+	right: 0;
+	text-decoration: none;
+	vertical-align: middle;
+	display: block;
+	width: 15px;
+	height: 15px;
+	line-height: 15px;
+	text-align: center;
+	background: #eee;
+	font-size: 15px;
+	-moz-border-radius: 15px;
+	border-radius: 15px;
+	-webkit-transition: opacity 200ms;
+	-moz-transition: opacity 200ms;
+	transition: opacity 200ms;
+	opacity: 0.3;
+	color: #888;
+}
+
+#mocha .test:hover a.replay {
+	opacity: 1;
+}
+
+#mocha-report.pass .test.fail {
+	display: none;
+}
+
+#mocha-report.fail .test.pass {
+	display: none;
+}
+
+#mocha-report.pending .test.pass,
+#mocha-report.pending .test.fail {
+	display: none;
+}
+
+#mocha-report.pending .test.pass.pending {
+	display: block;
+}
+
+#mocha-error {
+	color: #c00;
+	font-size: 1.5em;
+	font-weight: 100;
+	letter-spacing: 1px;
+}
+
+#mocha-stats {
+	position: fixed;
+	top: 15px;
+	right: 10px;
+	font-size: 12px;
+	margin: 0;
+	color: #888;
+	z-index: 1;
+}
+
+#mocha-stats .progress {
+	float: right;
+	padding-top: 0;
+}
+
+#mocha-stats em {
+	color: black;
+}
+
+#mocha-stats a {
+	text-decoration: none;
+	color: inherit;
+}
+
+#mocha-stats a:hover {
+	border-bottom: 1px solid #eee;
+}
+
+#mocha-stats li {
+	display: inline-block;
+	margin: 0 5px;
+	list-style: none;
+	padding-top: 11px;
+}
+
+#mocha-stats canvas {
+	width: 40px;
+	height: 40px;
+}
+
+#mocha code .comment {
+	color: #ddd;
+}
+
+#mocha code .init {
+	color: #2f6fad;
+}
+
+#mocha code .string {
+	color: #5890ad;
+}
+
+#mocha code .keyword {
+	color: #8a6343;
+}
+
+#mocha code .number {
+	color: #2f6fad;
+}
+
+@media screen and (max-device-width: 480px) {
+	#mocha {
+		margin: 60px 0px;
+	}
+
+	#mocha #stats {
+		position: absolute;
+	}
+}

package/p5-tests/test.html

@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+	<meta http-equiv="Content-type" content="text/html; charset=utf-8">
+	<link rel="stylesheet" href="mocha.css" />
+</head>
+
+<body>
+	<!-- Required for browser reporter -->
+	<div id="mocha"></div>
+
+	<!-- mocha -->
+	<script src="../node_modules/mocha/mocha.js"></script>
+	<script src="js/mocha_setup.js"></script>
+
+	<!-- Include your assertion lib of choice -->
+	<script src="../node_modules/chai/chai.js"></script>
+	<script src="js/sinon.js"></script>
+	<script src="js/modernizr.js"></script>
+	<script src="js/chai_helpers.js"></script>
+	<script src="js/p5_helpers.js"></script>
+
+	<!-- Include anything you want to test -->
+	<script src="../q5.js"></script>
+
+	<!-- Spec files (Now centralized in unit/spec.js) -->
+	<script src="unit/spec.js"></script>
+
+	<!-- run mocha -->
+	<script>
+		p5._throwValidationErrors = true;
+
+		window.addEventListener('load', function () {
+			var runner = mocha.run();
+
+			// NOTE: Sauce Labs removed, keeping these for now
+			// This exposes our test results to Sauce Labs. For more
+			// details, see: https://github.com/axemclion/grunt-saucelabs.
+
+			var failedTests = [];
+			runner.on('end', function () {
+				window.mochaResults = runner.stats;
+				window.mochaResults.reports = failedTests;
+			});
+
+			runner.on('fail', logFailure);
+
+			function logFailure(test, err) {
+				var flattenTitles = function (test) {
+					var titles = [];
+					while (test.parent.title) {
+						titles.push(test.parent.title);
+						test = test.parent;
+					}
+					return titles.reverse();
+				};
+
+				failedTests.push({
+					name: test.title,
+					result: false,
+					message: err.message,
+					stack: err.stack,
+					titles: flattenTitles(test)
+				});
+			}
+		}, false);
+	</script>
+</body>
+
+</html>

package/p5-tests/unit/color/color_conversion.js

@@ -0,0 +1,68 @@
+suite('color/p5.ColorConversion', function() {
+  var rgba = [1, 0, 0.4, 0.8];
+  var rgbaWithMaxHue = [1, 0, 0, 0.6];
+  var rgbaWithHighLightness = [0.969, 0.753, 0.122, 0.8];
+  var hsla = [336 / 360, 1, 0.5, 0.8];
+  var hslaWithMaxHue = [1, 1, 0.5, 0.6];
+  var hsba = [336 / 360, 1, 1, 0.8];
+  var hsbaWithMaxHue = [1, 1, 1, 0.6];
+  var accuracy = 0.01;
+  var result;
+
+  suite('rgbaToHSBA', function() {
+    test('rgba converts to hsba', function() {
+      result = p5.ColorConversion._rgbaToHSBA(rgba);
+      assert.arrayApproximately(result, hsba, accuracy);
+    });
+  });
+
+  suite('hsbaToRGBA', function() {
+    test('hsba converts to rgba', function() {
+      result = p5.ColorConversion._hsbaToRGBA(hsba);
+      assert.arrayApproximately(result, rgba, accuracy);
+    });
+
+    test('handles maximum hue value', function() {
+      result = p5.ColorConversion._hsbaToRGBA(hsbaWithMaxHue);
+      assert.arrayApproximately(result, rgbaWithMaxHue, accuracy);
+    });
+  });
+
+  suite('hslaToRGBA', function() {
+    test('hsla converts to rgba', function() {
+      result = p5.ColorConversion._hslaToRGBA(hsla);
+      assert.arrayApproximately(result, rgba, accuracy);
+    });
+
+    test('handles maximum hue value', function() {
+      result = p5.ColorConversion._hslaToRGBA(hslaWithMaxHue);
+      assert.arrayApproximately(result, rgbaWithMaxHue, accuracy);
+    });
+  });
+
+  suite('rgbaToHSLA', function() {
+    test('rgba converts to hsla (low lightness)', function() {
+      result = p5.ColorConversion._rgbaToHSLA(rgba);
+      assert.arrayApproximately(result, hsla, accuracy);
+    });
+
+    test('rgba converts to hsla (high lightness)', function() {
+      result = p5.ColorConversion._rgbaToHSLA(rgbaWithHighLightness);
+      assert.arrayApproximately(result, [0.12, 0.93, 0.55, 0.8], accuracy);
+    });
+  });
+
+  suite('hslaToHSBA', function() {
+    test('hsla converts to hsba', function() {
+      result = p5.ColorConversion._hslaToHSBA(hsla);
+      assert.arrayApproximately(result, hsba, accuracy);
+    });
+  });
+
+  suite('hsbaToHSLA', function() {
+    test('hsba converts to hsla', function() {
+      result = p5.ColorConversion._hsbaToHSLA(hsba);
+      assert.arrayApproximately(result, hsla, accuracy);
+    });
+  });
+});

package/p5-tests/unit/color/creating_reading.js

@@ -0,0 +1,217 @@
+suite('color/CreatingReading', function() {
+  var myp5;
+
+  setup(function(done) {
+    new p5(function(p) {
+      p.setup = function() {
+        myp5 = p;
+        done();
+      };
+    });
+  });
+
+  teardown(function() {
+    myp5.remove();
+  });
+
+  var fromColor;
+  var toColor;
+  var c;
+  var val;
+
+  suite('p5.prototype.alpha', function() {
+    setup(function() {
+      myp5.colorMode(myp5.RGB);
+    });
+    test('no friendly-err-msg I', function() {
+      assert.doesNotThrow(
+        function() {
+          var string = 'magenta';
+          c = myp5.color(string);
+          val = myp5.alpha(c);
+          assert.approximately(val, 255, 0.01);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('no friendly-err-msg II', function() {
+      assert.doesNotThrow(
+        function() {
+          c = myp5.color('hsba(160, 100%, 50%, 0.5)');
+          val = myp5.alpha(c);
+          assert.approximately(val, 127.5, 0.01);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('wrong param type at #0', function() {
+      assert.validationError(function() {
+        c = 20;
+        val = myp5.alpha(c);
+      });
+    });
+  });
+
+  suite('p5.prototype.red, green, blue', function() {
+    setup(function() {
+      myp5.colorMode(myp5.RGB);
+    });
+    test('red(): no friendly-err-msg', function() {
+      assert.doesNotThrow(
+        function() {
+          c = myp5.color('hsl(126, 100%, 60%)');
+          val = myp5.red(c);
+          assert.approximately(val, 51, 0.5);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('green(): no friendly-err-msg', function() {
+      assert.doesNotThrow(
+        function() {
+          c = myp5.color('hsl(126, 100%, 60%)');
+          val = myp5.green(c);
+          assert.approximately(val, 255, 0.5);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('blue(): no friendly-err-msg', function() {
+      assert.doesNotThrow(
+        function() {
+          c = myp5.color('hsl(126, 100%, 60%)');
+          val = myp5.blue(c);
+          assert.approximately(val, 71, 0.5);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+  });
+
+  suite('p5.prototype.hue, brightness, lightness, saturation', function() {
+    setup(function() {
+      myp5.colorMode(myp5.HSL);
+    });
+    test('hue(): no friendly-err-msg', function() {
+      assert.doesNotThrow(
+        function() {
+          c = myp5.color('#7fffd4');
+          val = myp5.hue(c);
+          assert.approximately(val, 160, 0.5);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('brightness(): no friendly-err-msg', function() {
+      assert.doesNotThrow(
+        function() {
+          c = myp5.color('#7fffd4');
+          val = myp5.brightness(c);
+          assert.approximately(val, 100, 0.5);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('lightness(): no friendly-err-msg', function() {
+      assert.doesNotThrow(
+        function() {
+          c = myp5.color('#7fffd4');
+          val = myp5.lightness(c);
+          assert.approximately(val, 75, 0.5);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+    test('saturation(): no friendly-err-msg', function() {
+      assert.doesNotThrow(
+        function() {
+          c = myp5.color('#7fffd4');
+          val = myp5.saturation(c);
+          assert.approximately(val, 100, 0.5);
+        },
+        Error,
+        'got unwanted exception'
+      );
+    });
+  });
+
+  suite('p5.prototype.lerpColor', function() {
+    setup(function() {
+      myp5.colorMode(myp5.RGB);
+      fromColor = myp5.color(218, 165, 32);
+      toColor = myp5.color(72, 61, 139);
+    });
+    test('should correctly get lerp colors in RGB', function() {
+      var interA = myp5.lerpColor(fromColor, toColor, 0.33);
+      var interB = myp5.lerpColor(fromColor, toColor, 0.66);
+      assert.deepEqual(interA.levels, [170, 131, 67, 255]);
+      assert.deepEqual(interB.levels, [122, 96, 103, 255]);
+    });
+    test('should correctly get lerp colors in HSL', function() {
+      myp5.colorMode(myp5.HSL);
+      var interA = myp5.lerpColor(fromColor, toColor, 0.33);
+      var interB = myp5.lerpColor(fromColor, toColor, 0.66);
+      assert.deepEqual(interA.levels, [190, 44, 63, 255]);
+      assert.deepEqual(interB.levels, [164, 53, 162, 255]);
+    });
+    test('should correctly get lerp colors in HSB', function() {
+      myp5.colorMode(myp5.HSB);
+      var interA = myp5.lerpColor(fromColor, toColor, 0.33);
+      var interB = myp5.lerpColor(fromColor, toColor, 0.66);
+      assert.deepEqual(interA.levels, [192, 47, 66, 255]);
+      assert.deepEqual(interB.levels, [166, 56, 164, 255]);
+    });
+    test('should not extrapolate', function() {
+      var interA = myp5.lerpColor(fromColor, toColor, -0.5);
+      var interB = myp5.lerpColor(fromColor, toColor, 1.5);
+      assert.deepEqual(interA.levels, [218, 165, 32, 255]);
+      assert.deepEqual(interB.levels, [72, 61, 139, 255]);
+    });
+    test('missing param #2', function() {
+      assert.validationError(function() {
+        myp5.lerpColor(fromColor, toColor);
+      });
+    });
+  });
+  suite('p5.prototype.lerpColor with alpha', function() {
+    setup(function() {
+      myp5.colorMode(myp5.RGB);
+      fromColor = myp5.color(218, 165, 32, 49);
+      toColor = myp5.color(72, 61, 139, 200);
+    });
+    test('should correctly get lerp colors in RGB with alpha', function() {
+      var interA = myp5.lerpColor(fromColor, toColor, 0.33);
+      var interB = myp5.lerpColor(fromColor, toColor, 0.66);
+      assert.deepEqual(interA.levels, [170, 131, 67, 99]);
+      assert.deepEqual(interB.levels, [122, 96, 103, 149]);
+    });
+    test('should correctly get lerp colors in HSL with alpha', function() {
+      myp5.colorMode(myp5.HSL);
+      var interA = myp5.lerpColor(fromColor, toColor, 0.33);
+      var interB = myp5.lerpColor(fromColor, toColor, 0.66);
+      assert.deepEqual(interA.levels, [190, 44, 63, 99]);
+      assert.deepEqual(interB.levels, [164, 53, 162, 149]);
+    });
+    test('should correctly get lerp colors in HSB with alpha', function() {
+      myp5.colorMode(myp5.HSB);
+      var interA = myp5.lerpColor(fromColor, toColor, 0.33);
+      var interB = myp5.lerpColor(fromColor, toColor, 0.66);
+      assert.deepEqual(interA.levels, [192, 47, 66, 99]);
+      assert.deepEqual(interB.levels, [166, 56, 164, 149]);
+    });
+    test('should not extrapolate', function() {
+      var interA = myp5.lerpColor(fromColor, toColor, -0.5);
+      var interB = myp5.lerpColor(fromColor, toColor, 1.5);
+      assert.deepEqual(interA.levels, [218, 165, 32, 49]);
+      assert.deepEqual(interB.levels, [72, 61, 139, 200]);
+    });
+  });
+});