"
+ }
+ ],
+ "dependencies": {},
+ "description": "String manipulation extensions for Underscore.js javascript library.",
+ "devDependencies": {},
+ "directories": {
+ "lib": "./lib"
+ },
+ "dist": {
+ "shasum": "71c08bf6b428b1133f37e78fa3a21c82f7329b0d",
+ "tarball": "https://registry.npmjs.org/underscore.string/-/underscore.string-2.3.3.tgz"
+ },
+ "engines": {
+ "node": "*"
+ },
+ "homepage": "http://epeli.github.com/underscore.string/",
+ "keywords": [
+ "underscore",
+ "string"
+ ],
+ "licenses": [
+ {
+ "type": "MIT"
+ }
+ ],
+ "main": "./lib/underscore.string",
+ "maintainers": [
+ {
+ "name": "edtsech",
+ "email": "edtsech@gmail.com"
+ },
+ {
+ "name": "rwz",
+ "email": "rwz@duckroll.ru"
+ },
+ {
+ "name": "epeli",
+ "email": "esa-matti@suuronen.org"
+ }
+ ],
+ "name": "underscore.string",
+ "optionalDependencies": {},
+ "readme": "ERROR: No README data found!",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/epeli/underscore.string.git"
+ },
+ "version": "2.3.3"
+}
diff --git a/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/run-qunit.js b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/run-qunit.js
new file mode 100644
index 0000000..44a2167
--- /dev/null
+++ b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/run-qunit.js
@@ -0,0 +1,45 @@
+function waitFor(test, complete, timeout) {
+ var result, start = new Date().getTime()
+ setInterval(function interval() {
+ if ((new Date().getTime() - start < timeout) && !result) {
+ result = test()
+ } else {
+ if (!result) {
+ phantom.exit(1)
+ } else {
+ complete()
+ clearInterval(interval)
+ }
+ }
+ }, 100)
+}
+
+
+var fs = require('fs'), page = require('webpage').create();
+var url = 'file://localhost' + fs.workingDirectory + '/' + phantom.args[0];
+
+page.onConsoleMessage = function(msg) {
+ console.log(msg)
+}
+
+page.open(url, function(status) {
+ waitFor(function() {
+ return page.evaluate(function(){
+ var el = document.getElementById('qunit-testresult')
+ return el && el.innerText.match('completed')
+ })
+ }, function() {
+ var failures = page.evaluate(function() {
+ var el = document.getElementById('qunit-testresult'),
+ fails = document.getElementsByClassName('fail')
+
+ for (var i = 0; i < fails.length; i++)
+ console.log(fails[i].innerText)
+
+ console.log(el.innerText)
+
+ return parseInt(el.getElementsByClassName('failed')[0].innerHTML)
+ })
+ phantom.exit(failures > 0 ? 1 : 0)
+ }, 10000)
+})
\ No newline at end of file
diff --git a/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/speed.js b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/speed.js
new file mode 100644
index 0000000..9ceeea7
--- /dev/null
+++ b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/speed.js
@@ -0,0 +1,148 @@
+(function() {
+
+ JSLitmus.test('levenshtein', function() {
+ return [
+ _.levenshtein('pineapple', 'potato'),
+ _.levenshtein('seven', 'eight'),
+ _.levenshtein('the very same string', 'the very same string'),
+ _.levenshtein('very very very long string', 'something completely different')
+ ];
+ });
+
+
+ JSLitmus.test('trimNoNative', function() {
+ return _.trim(" foobar ", " ");
+ });
+
+ JSLitmus.test('trim', function() {
+ return _.trim(" foobar ");
+ });
+
+ JSLitmus.test('trim object-oriented', function() {
+ return _(" foobar ").trim();
+ });
+
+ JSLitmus.test('trim jQuery', function() {
+ return jQuery.trim(" foobar ");
+ });
+
+ JSLitmus.test('ltrimp', function() {
+ return _.ltrim(" foobar ", " ");
+ });
+
+ JSLitmus.test('rtrimp', function() {
+ return _.rtrim(" foobar ", " ");
+ });
+
+ JSLitmus.test('startsWith', function() {
+ return _.startsWith("foobar", "foo");
+ });
+
+ JSLitmus.test('endsWith', function() {
+ return _.endsWith("foobar", "xx");
+ });
+
+ JSLitmus.test('chop', function(){
+ return _('whitespace').chop(2);
+ });
+
+ JSLitmus.test('count', function(){
+ return _('Hello worls').count('l');
+ });
+
+ JSLitmus.test('insert', function() {
+ return _('Hello ').insert(6, 'world');
+ });
+
+ JSLitmus.test('splice', function() {
+ return _('https://edtsech@bitbucket.org/edtsech/underscore.strings').splice(30, 7, 'epeli');
+ });
+
+ JSLitmus.test('succ', function(){
+ var let = 'a', alphabet = [];
+
+ for (var i=0; i < 26; i++) {
+ alphabet.push(let);
+ let = _(let).succ();
+ }
+
+ return alphabet;
+ });
+
+ JSLitmus.test('titleize', function(){
+ return _('the titleize string method').titleize();
+ });
+
+ JSLitmus.test('truncate', function(){
+ return _('Hello world').truncate(5);
+ });
+
+ JSLitmus.test('prune', function(){
+ return _('Hello world').prune(5);
+ });
+
+ JSLitmus.test('isBlank', function(){
+ return _('').isBlank();
+ });
+
+ JSLitmus.test('escapeHTML', function(){
+ _('Blah blah blah
').escapeHTML();
+ });
+
+ JSLitmus.test('unescapeHTML', function(){
+ _('<div>Blah blah blah</div>').unescapeHTML();
+ });
+
+ JSLitmus.test('reverse', function(){
+ _('Hello World').reverse();
+ });
+
+ JSLitmus.test('pad default', function(){
+ _('foo').pad(12);
+ });
+
+ JSLitmus.test('pad hash left', function(){
+ _('foo').pad(12, '#');
+ });
+
+ JSLitmus.test('pad hash right', function(){
+ _('foo').pad(12, '#', 'right');
+ });
+
+ JSLitmus.test('pad hash both', function(){
+ _('foo').pad(12, '#', 'both');
+ });
+
+ JSLitmus.test('pad hash both longPad', function(){
+ _('foo').pad(12, 'f00f00f00', 'both');
+ });
+
+ JSLitmus.test('toNumber', function(){
+ _('10.232323').toNumber(2);
+ });
+
+ JSLitmus.test('strRight', function(){
+ _('aaa_bbb_ccc').strRight('_');
+ });
+
+ JSLitmus.test('strRightBack', function(){
+ _('aaa_bbb_ccc').strRightBack('_');
+ });
+
+ JSLitmus.test('strLeft', function(){
+ _('aaa_bbb_ccc').strLeft('_');
+ });
+
+ JSLitmus.test('strLeftBack', function(){
+ _('aaa_bbb_ccc').strLeftBack('_');
+ });
+
+ JSLitmus.test('join', function(){
+ _('separator').join(1, 2, 3, 4, 5, 6, 7, 8, 'foo', 'bar', 'lol', 'wut');
+ });
+
+ JSLitmus.test('slugify', function(){
+ _("Un éléphant à l'orée du bois").slugify();
+ });
+
+})();
diff --git a/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/strings.js b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/strings.js
new file mode 100644
index 0000000..77364f2
--- /dev/null
+++ b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/strings.js
@@ -0,0 +1,685 @@
+$(document).ready(function() {
+
+ // Include Underscore.string methods to Underscore namespace
+ _.mixin(_.str.exports());
+
+ module('String extensions');
+
+ test('Strings: naturalSort', function() {
+ var arr = ['foo2', 'foo1', 'foo10', 'foo30', 'foo100', 'foo10bar'],
+ sorted = ['foo1', 'foo2', 'foo10', 'foo10bar', 'foo30', 'foo100'];
+ deepEqual(arr.sort(_.naturalCmp), sorted);
+ });
+
+ test('Strings: trim', function() {
+ equal(_.trim(123), '123', 'Non string');
+ equal(_(' foo').trim(), 'foo');
+ equal(_('foo ').trim(), 'foo');
+ equal(_(' foo ').trim(), 'foo');
+ equal(_(' foo ').trim(), 'foo');
+ equal(_(' foo ').trim(' '), 'foo', 'Manually set whitespace');
+ equal(_('\t foo \t ').trim(/\s/), 'foo', 'Manually set RegExp /\\s+/');
+
+ equal(_('ffoo').trim('f'), 'oo');
+ equal(_('ooff').trim('f'), 'oo');
+ equal(_('ffooff').trim('f'), 'oo');
+
+
+ equal(_('_-foobar-_').trim('_-'), 'foobar');
+
+ equal(_('http://foo/').trim('/'), 'http://foo');
+ equal(_('c:\\').trim('\\'), 'c:');
+
+ equal(_(123).trim(), '123');
+ equal(_(123).trim(3), '12');
+ equal(_('').trim(), '', 'Trim empty string should return empty string');
+ equal(_(null).trim(), '', 'Trim null should return empty string');
+ equal(_(undefined).trim(), '', 'Trim undefined should return empty string');
+ });
+
+ test('String: levenshtein', function() {
+ equal(_.levenshtein('Godfather', 'Godfather'), 0);
+ equal(_.levenshtein('Godfather', 'Godfathe'), 1);
+ equal(_.levenshtein('Godfather', 'odfather'), 1);
+ equal(_.levenshtein('Godfather', 'Gdfthr'), 3);
+ equal(_.levenshtein('seven', 'eight'), 5);
+ equal(_.levenshtein('123', 123), 0);
+ equal(_.levenshtein(321, '321'), 0);
+ equal(_.levenshtein('lol', null), 3);
+ equal(_.levenshtein('lol'), 3);
+ equal(_.levenshtein(null, 'lol'), 3);
+ equal(_.levenshtein(undefined, 'lol'), 3);
+ equal(_.levenshtein(), 0);
+ });
+
+ test('Strings: ltrim', function() {
+ equal(_(' foo').ltrim(), 'foo');
+ equal(_(' foo').ltrim(), 'foo');
+ equal(_('foo ').ltrim(), 'foo ');
+ equal(_(' foo ').ltrim(), 'foo ');
+ equal(_('').ltrim(), '', 'ltrim empty string should return empty string');
+ equal(_(null).ltrim(), '', 'ltrim null should return empty string');
+ equal(_(undefined).ltrim(), '', 'ltrim undefined should return empty string');
+
+ equal(_('ffoo').ltrim('f'), 'oo');
+ equal(_('ooff').ltrim('f'), 'ooff');
+ equal(_('ffooff').ltrim('f'), 'ooff');
+
+ equal(_('_-foobar-_').ltrim('_-'), 'foobar-_');
+
+ equal(_(123).ltrim(1), '23');
+ });
+
+ test('Strings: rtrim', function() {
+ equal(_('http://foo/').rtrim('/'), 'http://foo', 'clean trailing slash');
+ equal(_(' foo').rtrim(), ' foo');
+ equal(_('foo ').rtrim(), 'foo');
+ equal(_('foo ').rtrim(), 'foo');
+ equal(_('foo bar ').rtrim(), 'foo bar');
+ equal(_(' foo ').rtrim(), ' foo');
+
+ equal(_('ffoo').rtrim('f'), 'ffoo');
+ equal(_('ooff').rtrim('f'), 'oo');
+ equal(_('ffooff').rtrim('f'), 'ffoo');
+
+ equal(_('_-foobar-_').rtrim('_-'), '_-foobar');
+
+ equal(_(123).rtrim(3), '12');
+ equal(_('').rtrim(), '', 'rtrim empty string should return empty string');
+ equal(_(null).rtrim(), '', 'rtrim null should return empty string');
+ });
+
+ test('Strings: capitalize', function() {
+ equal(_('fabio').capitalize(), 'Fabio', 'First letter is upper case');
+ equal(_.capitalize('fabio'), 'Fabio', 'First letter is upper case');
+ equal(_.capitalize('FOO'), 'FOO', 'Other letters unchanged');
+ equal(_(123).capitalize(), '123', 'Non string');
+ equal(_.capitalize(''), '', 'Capitalizing empty string returns empty string');
+ equal(_.capitalize(null), '', 'Capitalizing null returns empty string');
+ equal(_.capitalize(undefined), '', 'Capitalizing undefined returns empty string');
+ });
+
+ test('Strings: join', function() {
+ equal(_.join('', 'foo', 'bar'), 'foobar', 'basic join');
+ equal(_.join('', 1, 'foo', 2), '1foo2', 'join numbers and strings');
+ equal(_.join(' ','foo', 'bar'), 'foo bar', 'join with spaces');
+ equal(_.join('1', '2', '2'), '212', 'join number strings');
+ equal(_.join(1, 2, 2), '212', 'join numbers');
+ equal(_.join('','foo', null), 'foo', 'join null with string returns string');
+ equal(_.join(null,'foo', 'bar'), 'foobar', 'join strings with null returns string');
+ equal(_(' ').join('foo', 'bar'), 'foo bar', 'join object oriented');
+ });
+
+ test('Strings: reverse', function() {
+ equal(_.str.reverse('foo'), 'oof' );
+ equal(_.str.reverse('foobar'), 'raboof' );
+ equal(_.str.reverse('foo bar'), 'rab oof' );
+ equal(_.str.reverse('saippuakauppias'), 'saippuakauppias' );
+ equal(_.str.reverse(123), '321', 'Non string');
+ equal(_.str.reverse(123.45), '54.321', 'Non string');
+ equal(_.str.reverse(''), '', 'reversing empty string returns empty string' );
+ equal(_.str.reverse(null), '', 'reversing null returns empty string' );
+ equal(_.str.reverse(undefined), '', 'reversing undefined returns empty string' );
+ });
+
+ test('Strings: clean', function() {
+ equal(_(' foo bar ').clean(), 'foo bar');
+ equal(_(123).clean(), '123');
+ equal(_('').clean(), '', 'claning empty string returns empty string');
+ equal(_(null).clean(), '', 'claning null returns empty string');
+ equal(_(undefined).clean(), '', 'claning undefined returns empty string');
+ });
+
+ test('Strings: sprintf', function() {
+ // Should be very tested function already. Thanks to
+ // http://www.diveintojavascript.com/projects/sprintf-for-javascript
+ equal(_.sprintf('Hello %s', 'me'), 'Hello me', 'basic');
+ equal(_('Hello %s').sprintf('me'), 'Hello me', 'object');
+ equal(_('hello %s').chain().sprintf('me').capitalize().value(), 'Hello me', 'Chaining works');
+ equal(_.sprintf('%.1f', 1.22222), '1.2', 'round');
+ equal(_.sprintf('%.1f', 1.17), '1.2', 'round 2');
+ equal(_.sprintf('%(id)d - %(name)s', {id: 824, name: 'Hello World'}), '824 - Hello World', 'Named replacements work');
+ equal(_.sprintf('%(args[0].id)d - %(args[1].name)s', {args: [{id: 824}, {name: 'Hello World'}]}), '824 - Hello World', 'Named replacements with arrays work');
+ });
+
+
+ test('Strings: vsprintf', function() {
+ equal(_.vsprintf('Hello %s', ['me']), 'Hello me', 'basic');
+ equal(_('Hello %s').vsprintf(['me']), 'Hello me', 'object');
+ equal(_('hello %s').chain().vsprintf(['me']).capitalize().value(), 'Hello me', 'Chaining works');
+ equal(_.vsprintf('%.1f', [1.22222]), '1.2', 'round');
+ equal(_.vsprintf('%.1f', [1.17]), '1.2', 'round 2');
+ equal(_.vsprintf('%(id)d - %(name)s', [{id: 824, name: 'Hello World'}]), '824 - Hello World', 'Named replacement works');
+ equal(_.vsprintf('%(args[0].id)d - %(args[1].name)s', [{args: [{id: 824}, {name: 'Hello World'}]}]), '824 - Hello World', 'Named replacement with arrays works');
+ });
+
+ test('Strings: startsWith', function() {
+ ok(_('foobar').startsWith('foo'), 'foobar starts with foo');
+ ok(!_('oobar').startsWith('foo'), 'oobar does not start with foo');
+ ok(_(12345).startsWith(123), '12345 starts with 123');
+ ok(!_(2345).startsWith(123), '2345 does not start with 123');
+ ok(_('').startsWith(''), 'empty string starts with empty string');
+ ok(_(null).startsWith(''), 'null starts with empty string');
+ ok(!_(null).startsWith('foo'), 'null starts with foo');
+ });
+
+ test('Strings: endsWith', function() {
+ ok(_('foobar').endsWith('bar'), 'foobar ends with bar');
+ ok(_.endsWith('foobar', 'bar'), 'foobar ends with bar');
+ ok(_.endsWith('00018-0000062.Plone.sdh264.1a7264e6912a91aa4a81b64dc5517df7b8875994.mp4', 'mp4'), 'endsWith .mp4');
+ ok(!_('fooba').endsWith('bar'), 'fooba does not end with bar');
+ ok(_.endsWith(12345, 45), '12345 ends with 45');
+ ok(!_.endsWith(12345, 6), '12345 does not end with 6');
+ ok(_('').endsWith(''), 'empty string ends with empty string');
+ ok(_(null).endsWith(''), 'null ends with empty string');
+ ok(!_(null).endsWith('foo'), 'null ends with foo');
+ });
+
+ test('Strings: include', function() {
+ ok(_.str.include('foobar', 'bar'), 'foobar includes bar');
+ ok(!_.str.include('foobar', 'buzz'), 'foobar does not includes buzz');
+ ok(_.str.include(12345, 34), '12345 includes 34');
+ ok(!_.str.contains(12345, 6), '12345 does not includes 6');
+ ok(!_.str.include('', 34), 'empty string includes 34');
+ ok(!_.str.include(null, 34), 'null includes 34');
+ ok(_.str.include(null, ''), 'null includes empty string');
+ });
+
+ test('String: chop', function(){
+ ok(_('whitespace').chop(2).length === 5, 'output [wh, it, es, pa, ce]');
+ ok(_('whitespace').chop(3).length === 4, 'output [whi, tes, pac, e]');
+ ok(_('whitespace').chop()[0].length === 10, 'output [whitespace]');
+ ok(_(12345).chop(1).length === 5, 'output [1, 2, 3, 4, 5]');
+ });
+
+ test('String: clean', function(){
+ equal(_.clean(' foo bar '), 'foo bar');
+ equal(_.clean(''), '');
+ equal(_.clean(null), '');
+ equal(_.clean(1), '1');
+ });
+
+ test('String: count', function(){
+ equal(_('Hello world').count('l'), 3);
+ equal(_('Hello world').count('Hello'), 1);
+ equal(_('Hello world').count('foo'), 0);
+ equal(_('x.xx....x.x').count('x'), 5);
+ equal(_('').count('x'), 0);
+ equal(_(null).count('x'), 0);
+ equal(_(undefined).count('x'), 0);
+ equal(_(12345).count(1), 1);
+ equal(_(11345).count(1), 2);
+ });
+
+ test('String: insert', function(){
+ equal(_('Hello ').insert(6, 'Jessy'), 'Hello Jessy');
+ equal(_('Hello ').insert(100, 'Jessy'), 'Hello Jessy');
+ equal(_('').insert(100, 'Jessy'), 'Jessy');
+ equal(_(null).insert(100, 'Jessy'), 'Jessy');
+ equal(_(undefined).insert(100, 'Jessy'), 'Jessy');
+ equal(_(12345).insert(6, 'Jessy'), '12345Jessy');
+ });
+
+ test('String: splice', function(){
+ equal(_('https://edtsech@bitbucket.org/edtsech/underscore.strings').splice(30, 7, 'epeli'),
+ 'https://edtsech@bitbucket.org/epeli/underscore.strings');
+ equal(_.splice(12345, 1, 2, 321), '132145', 'Non strings');
+ });
+
+ test('String: succ', function(){
+ equal(_('a').succ(), 'b');
+ equal(_('A').succ(), 'B');
+ equal(_('+').succ(), ',');
+ equal(_(1).succ(), '2');
+ });
+
+ test('String: titleize', function(){
+ equal(_('the titleize string method').titleize(), 'The Titleize String Method');
+ equal(_('the titleize string method').titleize(), 'The Titleize String Method');
+ equal(_('').titleize(), '', 'Titleize empty string returns empty string');
+ equal(_(null).titleize(), '', 'Titleize null returns empty string');
+ equal(_(undefined).titleize(), '', 'Titleize undefined returns empty string');
+ equal(_('let\'s have some fun').titleize(), 'Let\'s Have Some Fun');
+ equal(_('a-dash-separated-string').titleize(), 'A-Dash-Separated-String');
+ equal(_('A-DASH-SEPARATED-STRING').titleize(), 'A-Dash-Separated-String');
+ equal(_(123).titleize(), '123');
+ });
+
+ test('String: camelize', function(){
+ equal(_('the_camelize_string_method').camelize(), 'theCamelizeStringMethod');
+ equal(_('-the-camelize-string-method').camelize(), 'TheCamelizeStringMethod');
+ equal(_('the camelize string method').camelize(), 'theCamelizeStringMethod');
+ equal(_(' the camelize string method').camelize(), 'theCamelizeStringMethod');
+ equal(_('the camelize string method').camelize(), 'theCamelizeStringMethod');
+ equal(_('').camelize(), '', 'Camelize empty string returns empty string');
+ equal(_(null).camelize(), '', 'Camelize null returns empty string');
+ equal(_(undefined).camelize(), '', 'Camelize undefined returns empty string');
+ equal(_(123).camelize(), '123');
+ });
+
+ test('String: underscored', function(){
+ equal(_('the-underscored-string-method').underscored(), 'the_underscored_string_method');
+ equal(_('theUnderscoredStringMethod').underscored(), 'the_underscored_string_method');
+ equal(_('TheUnderscoredStringMethod').underscored(), 'the_underscored_string_method');
+ equal(_(' the underscored string method').underscored(), 'the_underscored_string_method');
+ equal(_('').underscored(), '');
+ equal(_(null).underscored(), '');
+ equal(_(undefined).underscored(), '');
+ equal(_(123).underscored(), '123');
+ });
+
+ test('String: dasherize', function(){
+ equal(_('the_dasherize_string_method').dasherize(), 'the-dasherize-string-method');
+ equal(_('TheDasherizeStringMethod').dasherize(), '-the-dasherize-string-method');
+ equal(_('thisIsATest').dasherize(), 'this-is-a-test');
+ equal(_('this Is A Test').dasherize(), 'this-is-a-test');
+ equal(_('thisIsATest123').dasherize(), 'this-is-a-test123');
+ equal(_('123thisIsATest').dasherize(), '123this-is-a-test');
+ equal(_('the dasherize string method').dasherize(), 'the-dasherize-string-method');
+ equal(_('the dasherize string method ').dasherize(), 'the-dasherize-string-method');
+ equal(_('téléphone').dasherize(), 'téléphone');
+ equal(_('foo$bar').dasherize(), 'foo$bar');
+ equal(_('').dasherize(), '');
+ equal(_(null).dasherize(), '');
+ equal(_(undefined).dasherize(), '');
+ equal(_(123).dasherize(), '123');
+ });
+
+ test('String: camelize', function(){
+ equal(_.camelize('-moz-transform'), 'MozTransform');
+ equal(_.camelize('webkit-transform'), 'webkitTransform');
+ equal(_.camelize('under_scored'), 'underScored');
+ equal(_.camelize(' with spaces'), 'withSpaces');
+ equal(_('').camelize(), '');
+ equal(_(null).camelize(), '');
+ equal(_(undefined).camelize(), '');
+ equal(_("_som eWeird---name-").camelize(), 'SomEWeirdName');
+ });
+
+ test('String: join', function(){
+ equal(_.join(1, 2, 3, 4), '21314');
+ equal(_.join('|', 'foo', 'bar', 'baz'), 'foo|bar|baz');
+ equal(_.join('',2,3,null), '23');
+ equal(_.join(null,2,3), '23');
+ });
+
+ test('String: classify', function(){
+ equal(_.classify(1), '1');
+ equal(_('some_class_name').classify(), 'SomeClassName');
+ equal(_('my wonderfull class_name').classify(), 'MyWonderfullClassName');
+ equal(_('my wonderfull.class.name').classify(), 'MyWonderfullClassName');
+ });
+
+ test('String: humanize', function(){
+ equal(_('the_humanize_string_method').humanize(), 'The humanize string method');
+ equal(_('ThehumanizeStringMethod').humanize(), 'Thehumanize string method');
+ equal(_('the humanize string method').humanize(), 'The humanize string method');
+ equal(_('the humanize_id string method_id').humanize(), 'The humanize id string method');
+ equal(_('the humanize string method ').humanize(), 'The humanize string method');
+ equal(_(' capitalize dash-CamelCase_underscore trim ').humanize(), 'Capitalize dash camel case underscore trim');
+ equal(_(123).humanize(), '123');
+ equal(_('').humanize(), '');
+ equal(_(null).humanize(), '');
+ equal(_(undefined).humanize(), '');
+ });
+
+ test('String: truncate', function(){
+ equal(_('Hello world').truncate(6, 'read more'), 'Hello read more');
+ equal(_('Hello world').truncate(5), 'Hello...');
+ equal(_('Hello').truncate(10), 'Hello');
+ equal(_('').truncate(10), '');
+ equal(_(null).truncate(10), '');
+ equal(_(undefined).truncate(10), '');
+ equal(_(1234567890).truncate(5), '12345...');
+ });
+
+ test('String: prune', function(){
+ equal(_('Hello, cruel world').prune(6, ' read more'), 'Hello read more');
+ equal(_('Hello, world').prune(5, 'read a lot more'), 'Hello, world');
+ equal(_('Hello, world').prune(5), 'Hello...');
+ equal(_('Hello, world').prune(8), 'Hello...');
+ equal(_('Hello, cruel world').prune(15), 'Hello, cruel...');
+ equal(_('Hello world').prune(22), 'Hello world');
+ equal(_('Привет, жестокий мир').prune(6, ' read more'), 'Привет read more');
+ equal(_('Привет, мир').prune(6, 'read a lot more'), 'Привет, мир');
+ equal(_('Привет, мир').prune(6), 'Привет...');
+ equal(_('Привет, мир').prune(8), 'Привет...');
+ equal(_('Привет, жестокий мир').prune(16), 'Привет, жестокий...');
+ equal(_('Привет, мир').prune(22), 'Привет, мир');
+ equal(_('alksjd!!!!!!....').prune(100, ''), 'alksjd!!!!!!....');
+ equal(_(123).prune(10), '123');
+ equal(_(123).prune(1, 321), '321');
+ equal(_('').prune(5), '');
+ equal(_(null).prune(5), '');
+ equal(_(undefined).prune(5), '');
+ });
+
+ test('String: isBlank', function(){
+ ok(_('').isBlank());
+ ok(_(' ').isBlank());
+ ok(_('\n').isBlank());
+ ok(!_('a').isBlank());
+ ok(!_('0').isBlank());
+ ok(!_(0).isBlank());
+ ok(_('').isBlank());
+ ok(_(null).isBlank());
+ ok(_(undefined).isBlank());
+ });
+
+ test('String: escapeRegExp', function(){
+ equal(_.escapeRegExp(/hello(?=\sworld)/.source), 'hello\\(\\?\\=\\\\sworld\\)', 'with lookahead');
+ equal(_.escapeRegExp(/hello(?!\shell)/.source), 'hello\\(\\?\\!\\\\shell\\)', 'with negative lookahead');
+ });
+
+ test('String: escapeHTML', function(){
+ equal(_('Blah & "blah" & \'blah\'
').escapeHTML(),
+ '<div>Blah & "blah" & 'blah'</div>');
+ equal(_('<').escapeHTML(), '<');
+ equal(_(5).escapeHTML(), '5');
+ equal(_('').escapeHTML(), '');
+ equal(_(null).escapeHTML(), '');
+ equal(_(undefined).escapeHTML(), '');
+ });
+
+ test('String: unescapeHTML', function(){
+ equal(_('<div>Blah & "blah" & 'blah'</div>').unescapeHTML(),
+ 'Blah & "blah" & \'blah\'
');
+ equal(_('<').unescapeHTML(), '<');
+ equal(_(''').unescapeHTML(), '\'');
+ equal(_(''').unescapeHTML(), '\'');
+ equal(_(''').unescapeHTML(), '\'');
+ equal(_('J').unescapeHTML(), 'J');
+ equal(_('J').unescapeHTML(), 'J');
+ equal(_('J').unescapeHTML(), 'J');
+ equal(_('&_#39;').unescapeHTML(), '&_#39;');
+ equal(_(''_;').unescapeHTML(), ''_;');
+ equal(_('&').unescapeHTML(), '&');
+ equal(_('&').unescapeHTML(), '&');
+ equal(_('').unescapeHTML(), '');
+ equal(_(null).unescapeHTML(), '');
+ equal(_(undefined).unescapeHTML(), '');
+ equal(_(5).unescapeHTML(), '5');
+ // equal(_(undefined).unescapeHTML(), '');
+ });
+
+ test('String: words', function() {
+ deepEqual(_('I love you!').words(), ['I', 'love', 'you!']);
+ deepEqual(_(' I love you! ').words(), ['I', 'love', 'you!']);
+ deepEqual(_('I_love_you!').words('_'), ['I', 'love', 'you!']);
+ deepEqual(_('I-love-you!').words(/-/), ['I', 'love', 'you!']);
+ deepEqual(_(123).words(), ['123'], '123 number has one word "123".');
+ deepEqual(_(0).words(), ['0'], 'Zero number has one word "0".');
+ deepEqual(_('').words(), [], 'Empty strings has no words.');
+ deepEqual(_(' ').words(), [], 'Blank strings has no words.');
+ deepEqual(_(null).words(), [], 'null has no words.');
+ deepEqual(_(undefined).words(), [], 'undefined has no words.');
+ });
+
+ test('String: chars', function() {
+ equal(_('Hello').chars().length, 5);
+ equal(_(123).chars().length, 3);
+ equal(_('').chars().length, 0);
+ equal(_(null).chars().length, 0);
+ equal(_(undefined).chars().length, 0);
+ });
+
+ test('String: swapCase', function(){
+ equal(_('AaBbCcDdEe').swapCase(), 'aAbBcCdDeE');
+ equal(_('Hello World').swapCase(), 'hELLO wORLD');
+ equal(_('').swapCase(), '');
+ equal(_(null).swapCase(), '');
+ equal(_(undefined).swapCase(), '');
+ });
+
+ test('String: lines', function() {
+ equal(_('Hello\nWorld').lines().length, 2);
+ equal(_('Hello World').lines().length, 1);
+ equal(_(123).lines().length, 1);
+ equal(_('').lines().length, 1);
+ equal(_(null).lines().length, 0);
+ equal(_(undefined).lines().length, 0);
+ });
+
+ test('String: pad', function() {
+ equal(_('1').pad(8), ' 1');
+ equal(_(1).pad(8), ' 1');
+ equal(_('1').pad(8, '0'), '00000001');
+ equal(_('1').pad(8, '0', 'left'), '00000001');
+ equal(_('1').pad(8, '0', 'right'), '10000000');
+ equal(_('1').pad(8, '0', 'both'), '00001000');
+ equal(_('foo').pad(8, '0', 'both'), '000foo00');
+ equal(_('foo').pad(7, '0', 'both'), '00foo00');
+ equal(_('foo').pad(7, '!@$%dofjrofj', 'both'), '!!foo!!');
+ equal(_('').pad(2), ' ');
+ equal(_(null).pad(2), ' ');
+ equal(_(undefined).pad(2), ' ');
+ });
+
+ test('String: lpad', function() {
+ equal(_('1').lpad(8), ' 1');
+ equal(_(1).lpad(8), ' 1');
+ equal(_('1').lpad(8, '0'), '00000001');
+ equal(_('1').lpad(8, '0', 'left'), '00000001');
+ equal(_('').lpad(2), ' ');
+ equal(_(null).lpad(2), ' ');
+ equal(_(undefined).lpad(2), ' ');
+ });
+
+ test('String: rpad', function() {
+ equal(_('1').rpad(8), '1 ');
+ equal(_(1).lpad(8), ' 1');
+ equal(_('1').rpad(8, '0'), '10000000');
+ equal(_('foo').rpad(8, '0'), 'foo00000');
+ equal(_('foo').rpad(7, '0'), 'foo0000');
+ equal(_('').rpad(2), ' ');
+ equal(_(null).rpad(2), ' ');
+ equal(_(undefined).rpad(2), ' ');
+ });
+
+ test('String: lrpad', function() {
+ equal(_('1').lrpad(8), ' 1 ');
+ equal(_(1).lrpad(8), ' 1 ');
+ equal(_('1').lrpad(8, '0'), '00001000');
+ equal(_('foo').lrpad(8, '0'), '000foo00');
+ equal(_('foo').lrpad(7, '0'), '00foo00');
+ equal(_('foo').lrpad(7, '!@$%dofjrofj'), '!!foo!!');
+ equal(_('').lrpad(2), ' ');
+ equal(_(null).lrpad(2), ' ');
+ equal(_(undefined).lrpad(2), ' ');
+ });
+
+ test('String: toNumber', function() {
+ deepEqual(_('not a number').toNumber(), NaN);
+ equal(_(0).toNumber(), 0);
+ equal(_('0').toNumber(), 0);
+ equal(_('0.0').toNumber(), 0);
+ equal(_('0.1').toNumber(), 0);
+ equal(_('0.1').toNumber(1), 0.1);
+ equal(_(' 0.1 ').toNumber(1), 0.1);
+ equal(_('0000').toNumber(), 0);
+ equal(_('2.345').toNumber(), 2);
+ equal(_('2.345').toNumber(NaN), 2);
+ equal(_('2.345').toNumber(2), 2.35);
+ equal(_('2.344').toNumber(2), 2.34);
+ equal(_('2').toNumber(2), 2.00);
+ equal(_(2).toNumber(2), 2.00);
+ equal(_(-2).toNumber(), -2);
+ equal(_('-2').toNumber(), -2);
+ equal(_('').toNumber(), 0);
+ equal(_(null).toNumber(), 0);
+ equal(_(undefined).toNumber(), 0);
+ });
+
+ test('String: numberFormat', function() {
+ equal(_.numberFormat(9000), '9,000');
+ equal(_.numberFormat(9000, 0), '9,000');
+ equal(_.numberFormat(9000, 0, '', ''), '9000');
+ equal(_.numberFormat(90000, 2), '90,000.00');
+ equal(_.numberFormat(1000.754), '1,001');
+ equal(_.numberFormat(1000.754, 2), '1,000.75');
+ equal(_.numberFormat(1000.754, 0, ',', '.'), '1.001');
+ equal(_.numberFormat(1000.754, 2, ',', '.'), '1.000,75');
+ equal(_.numberFormat(1000000.754, 2, ',', '.'), '1.000.000,75');
+ equal(_.numberFormat(1000000000), '1,000,000,000');
+ equal(_.numberFormat(100000000), '100,000,000');
+ equal(_.numberFormat('not number'), '');
+ equal(_.numberFormat(), '');
+ equal(_.numberFormat(null, '.', ','), '');
+ equal(_.numberFormat(undefined, '.', ','), '');
+ equal(_.numberFormat(new Number(5000)), '5,000');
+ });
+
+ test('String: strRight', function() {
+ equal(_('This_is_a_test_string').strRight('_'), 'is_a_test_string');
+ equal(_('This_is_a_test_string').strRight('string'), '');
+ equal(_('This_is_a_test_string').strRight(), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strRight(''), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strRight('-'), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strRight(''), 'This_is_a_test_string');
+ equal(_('').strRight('foo'), '');
+ equal(_(null).strRight('foo'), '');
+ equal(_(undefined).strRight('foo'), '');
+ equal(_(12345).strRight(2), '345');
+ });
+
+ test('String: strRightBack', function() {
+ equal(_('This_is_a_test_string').strRightBack('_'), 'string');
+ equal(_('This_is_a_test_string').strRightBack('string'), '');
+ equal(_('This_is_a_test_string').strRightBack(), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strRightBack(''), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strRightBack('-'), 'This_is_a_test_string');
+ equal(_('').strRightBack('foo'), '');
+ equal(_(null).strRightBack('foo'), '');
+ equal(_(undefined).strRightBack('foo'), '');
+ equal(_(12345).strRightBack(2), '345');
+ });
+
+ test('String: strLeft', function() {
+ equal(_('This_is_a_test_string').strLeft('_'), 'This');
+ equal(_('This_is_a_test_string').strLeft('This'), '');
+ equal(_('This_is_a_test_string').strLeft(), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strLeft(''), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strLeft('-'), 'This_is_a_test_string');
+ equal(_('').strLeft('foo'), '');
+ equal(_(null).strLeft('foo'), '');
+ equal(_(undefined).strLeft('foo'), '');
+ equal(_(123454321).strLeft(3), '12');
+ });
+
+ test('String: strLeftBack', function() {
+ equal(_('This_is_a_test_string').strLeftBack('_'), 'This_is_a_test');
+ equal(_('This_is_a_test_string').strLeftBack('This'), '');
+ equal(_('This_is_a_test_string').strLeftBack(), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strLeftBack(''), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strLeftBack('-'), 'This_is_a_test_string');
+ equal(_('').strLeftBack('foo'), '');
+ equal(_(null).strLeftBack('foo'), '');
+ equal(_(undefined).strLeftBack('foo'), '');
+ equal(_(123454321).strLeftBack(3), '123454');
+ });
+
+ test('Strings: stripTags', function() {
+ equal(_('a link').stripTags(), 'a link');
+ equal(_('a link
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_standalone.html b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_standalone.html
new file mode 100644
index 0000000..9854c17
--- /dev/null
+++ b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_standalone.html
@@ -0,0 +1,18 @@
+
+
+
+ Underscore.strings Test Suite
+
+
+
+
+
+
+
+
+
+
+
+
+
+
diff --git a/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/arrays.js b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/arrays.js
new file mode 100644
index 0000000..32252a3
--- /dev/null
+++ b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/arrays.js
@@ -0,0 +1,200 @@
+$(document).ready(function() {
+
+ module("Arrays");
+
+ test("first", function() {
+ equal(_.first([1,2,3]), 1, 'can pull out the first element of an array');
+ equal(_([1, 2, 3]).first(), 1, 'can perform OO-style "first()"');
+ equal(_.first([1,2,3], 0).join(', '), "", 'can pass an index to first');
+ equal(_.first([1,2,3], 2).join(', '), '1, 2', 'can pass an index to first');
+ equal(_.first([1,2,3], 5).join(', '), '1, 2, 3', 'can pass an index to first');
+ var result = (function(){ return _.first(arguments); })(4, 3, 2, 1);
+ equal(result, 4, 'works on an arguments object.');
+ result = _.map([[1,2,3],[1,2,3]], _.first);
+ equal(result.join(','), '1,1', 'works well with _.map');
+ result = (function() { return _.take([1,2,3], 2); })();
+ equal(result.join(','), '1,2', 'aliased as take');
+
+ equal(_.first(null), undefined, 'handles nulls');
+ });
+
+ test("rest", function() {
+ var numbers = [1, 2, 3, 4];
+ equal(_.rest(numbers).join(", "), "2, 3, 4", 'working rest()');
+ equal(_.rest(numbers, 0).join(", "), "1, 2, 3, 4", 'working rest(0)');
+ equal(_.rest(numbers, 2).join(', '), '3, 4', 'rest can take an index');
+ var result = (function(){ return _(arguments).tail(); })(1, 2, 3, 4);
+ equal(result.join(', '), '2, 3, 4', 'aliased as tail and works on arguments object');
+ result = _.map([[1,2,3],[1,2,3]], _.rest);
+ equal(_.flatten(result).join(','), '2,3,2,3', 'works well with _.map');
+ result = (function(){ return _(arguments).drop(); })(1, 2, 3, 4);
+ equal(result.join(', '), '2, 3, 4', 'aliased as drop and works on arguments object');
+ });
+
+ test("initial", function() {
+ equal(_.initial([1,2,3,4,5]).join(", "), "1, 2, 3, 4", 'working initial()');
+ equal(_.initial([1,2,3,4],2).join(", "), "1, 2", 'initial can take an index');
+ var result = (function(){ return _(arguments).initial(); })(1, 2, 3, 4);
+ equal(result.join(", "), "1, 2, 3", 'initial works on arguments object');
+ result = _.map([[1,2,3],[1,2,3]], _.initial);
+ equal(_.flatten(result).join(','), '1,2,1,2', 'initial works with _.map');
+ });
+
+ test("last", function() {
+ equal(_.last([1,2,3]), 3, 'can pull out the last element of an array');
+ equal(_.last([1,2,3], 0).join(', '), "", 'can pass an index to last');
+ equal(_.last([1,2,3], 2).join(', '), '2, 3', 'can pass an index to last');
+ equal(_.last([1,2,3], 5).join(', '), '1, 2, 3', 'can pass an index to last');
+ var result = (function(){ return _(arguments).last(); })(1, 2, 3, 4);
+ equal(result, 4, 'works on an arguments object');
+ result = _.map([[1,2,3],[1,2,3]], _.last);
+ equal(result.join(','), '3,3', 'works well with _.map');
+
+ equal(_.last(null), undefined, 'handles nulls');
+ });
+
+ test("compact", function() {
+ equal(_.compact([0, 1, false, 2, false, 3]).length, 3, 'can trim out all falsy values');
+ var result = (function(){ return _(arguments).compact().length; })(0, 1, false, 2, false, 3);
+ equal(result, 3, 'works on an arguments object');
+ });
+
+ test("flatten", function() {
+ if (window.JSON) {
+ var list = [1, [2], [3, [[[4]]]]];
+ equal(JSON.stringify(_.flatten(list)), '[1,2,3,4]', 'can flatten nested arrays');
+ equal(JSON.stringify(_.flatten(list, true)), '[1,2,3,[[[4]]]]', 'can shallowly flatten nested arrays');
+ var result = (function(){ return _.flatten(arguments); })(1, [2], [3, [[[4]]]]);
+ equal(JSON.stringify(result), '[1,2,3,4]', 'works on an arguments object');
+ }
+ });
+
+ test("without", function() {
+ var list = [1, 2, 1, 0, 3, 1, 4];
+ equal(_.without(list, 0, 1).join(', '), '2, 3, 4', 'can remove all instances of an object');
+ var result = (function(){ return _.without(arguments, 0, 1); })(1, 2, 1, 0, 3, 1, 4);
+ equal(result.join(', '), '2, 3, 4', 'works on an arguments object');
+
+ var list = [{one : 1}, {two : 2}];
+ ok(_.without(list, {one : 1}).length == 2, 'uses real object identity for comparisons.');
+ ok(_.without(list, list[0]).length == 1, 'ditto.');
+ });
+
+ test("uniq", function() {
+ var list = [1, 2, 1, 3, 1, 4];
+ equal(_.uniq(list).join(', '), '1, 2, 3, 4', 'can find the unique values of an unsorted array');
+
+ var list = [1, 1, 1, 2, 2, 3];
+ equal(_.uniq(list, true).join(', '), '1, 2, 3', 'can find the unique values of a sorted array faster');
+
+ var list = [{name:'moe'}, {name:'curly'}, {name:'larry'}, {name:'curly'}];
+ var iterator = function(value) { return value.name; };
+ equal(_.map(_.uniq(list, false, iterator), iterator).join(', '), 'moe, curly, larry', 'can find the unique values of an array using a custom iterator');
+
+ var iterator = function(value) { return value +1; };
+ var list = [1, 2, 2, 3, 4, 4];
+ equal(_.uniq(list, true, iterator).join(', '), '1, 2, 3, 4', 'iterator works with sorted array');
+
+ var result = (function(){ return _.uniq(arguments); })(1, 2, 1, 3, 1, 4);
+ equal(result.join(', '), '1, 2, 3, 4', 'works on an arguments object');
+ });
+
+ test("intersection", function() {
+ var stooges = ['moe', 'curly', 'larry'], leaders = ['moe', 'groucho'];
+ equal(_.intersection(stooges, leaders).join(''), 'moe', 'can take the set intersection of two arrays');
+ equal(_(stooges).intersection(leaders).join(''), 'moe', 'can perform an OO-style intersection');
+ var result = (function(){ return _.intersection(arguments, leaders); })('moe', 'curly', 'larry');
+ equal(result.join(''), 'moe', 'works on an arguments object');
+ });
+
+ test("union", function() {
+ var result = _.union([1, 2, 3], [2, 30, 1], [1, 40]);
+ equal(result.join(' '), '1 2 3 30 40', 'takes the union of a list of arrays');
+
+ var result = _.union([1, 2, 3], [2, 30, 1], [1, 40, [1]]);
+ equal(result.join(' '), '1 2 3 30 40 1', 'takes the union of a list of nested arrays');
+ });
+
+ test("difference", function() {
+ var result = _.difference([1, 2, 3], [2, 30, 40]);
+ equal(result.join(' '), '1 3', 'takes the difference of two arrays');
+
+ var result = _.difference([1, 2, 3, 4], [2, 30, 40], [1, 11, 111]);
+ equal(result.join(' '), '3 4', 'takes the difference of three arrays');
+ });
+
+ test('zip', function() {
+ var names = ['moe', 'larry', 'curly'], ages = [30, 40, 50], leaders = [true];
+ var stooges = _.zip(names, ages, leaders);
+ equal(String(stooges), 'moe,30,true,larry,40,,curly,50,', 'zipped together arrays of different lengths');
+ });
+
+ test('object', function() {
+ var result = _.object(['moe', 'larry', 'curly'], [30, 40, 50]);
+ var shouldBe = {moe: 30, larry: 40, curly: 50};
+ ok(_.isEqual(result, shouldBe), 'two arrays zipped together into an object');
+
+ result = _.object([['one', 1], ['two', 2], ['three', 3]]);
+ shouldBe = {one: 1, two: 2, three: 3};
+ ok(_.isEqual(result, shouldBe), 'an array of pairs zipped together into an object');
+
+ var stooges = {moe: 30, larry: 40, curly: 50};
+ ok(_.isEqual(_.object(_.pairs(stooges)), stooges), 'an object converted to pairs and back to an object');
+
+ ok(_.isEqual(_.object(null), {}), 'handles nulls');
+ });
+
+ test("indexOf", function() {
+ var numbers = [1, 2, 3];
+ numbers.indexOf = null;
+ equal(_.indexOf(numbers, 2), 1, 'can compute indexOf, even without the native function');
+ var result = (function(){ return _.indexOf(arguments, 2); })(1, 2, 3);
+ equal(result, 1, 'works on an arguments object');
+ equal(_.indexOf(null, 2), -1, 'handles nulls properly');
+
+ var numbers = [10, 20, 30, 40, 50], num = 35;
+ var index = _.indexOf(numbers, num, true);
+ equal(index, -1, '35 is not in the list');
+
+ numbers = [10, 20, 30, 40, 50]; num = 40;
+ index = _.indexOf(numbers, num, true);
+ equal(index, 3, '40 is in the list');
+
+ numbers = [1, 40, 40, 40, 40, 40, 40, 40, 50, 60, 70]; num = 40;
+ index = _.indexOf(numbers, num, true);
+ equal(index, 1, '40 is in the list');
+
+ numbers = [1, 2, 3, 1, 2, 3, 1, 2, 3];
+ index = _.indexOf(numbers, 2, 5);
+ equal(index, 7, 'supports the fromIndex argument');
+ });
+
+ test("lastIndexOf", function() {
+ var numbers = [1, 0, 1];
+ equal(_.lastIndexOf(numbers, 1), 2);
+
+ numbers = [1, 0, 1, 0, 0, 1, 0, 0, 0];
+ numbers.lastIndexOf = null;
+ equal(_.lastIndexOf(numbers, 1), 5, 'can compute lastIndexOf, even without the native function');
+ equal(_.lastIndexOf(numbers, 0), 8, 'lastIndexOf the other element');
+ var result = (function(){ return _.lastIndexOf(arguments, 1); })(1, 0, 1, 0, 0, 1, 0, 0, 0);
+ equal(result, 5, 'works on an arguments object');
+ equal(_.indexOf(null, 2), -1, 'handles nulls properly');
+
+ numbers = [1, 2, 3, 1, 2, 3, 1, 2, 3];
+ index = _.lastIndexOf(numbers, 2, 2);
+ equal(index, 1, 'supports the fromIndex argument');
+ });
+
+ test("range", function() {
+ equal(_.range(0).join(''), '', 'range with 0 as a first argument generates an empty array');
+ equal(_.range(4).join(' '), '0 1 2 3', 'range with a single positive argument generates an array of elements 0,1,2,...,n-1');
+ equal(_.range(5, 8).join(' '), '5 6 7', 'range with two arguments a & b, a<b generates an array of elements a,a+1,a+2,...,b-2,b-1');
+ equal(_.range(8, 5).join(''), '', 'range with two arguments a & b, b<a generates an empty array');
+ equal(_.range(3, 10, 3).join(' '), '3 6 9', 'range with three arguments a & b & c, c < b-a, a < b generates an array of elements a,a+c,a+2c,...,b - (multiplier of a) < c');
+ equal(_.range(3, 10, 15).join(''), '3', 'range with three arguments a & b & c, c > b-a, a < b generates an array with a single element, equal to a');
+ equal(_.range(12, 7, -2).join(' '), '12 10 8', 'range with three arguments a & b & c, a > b, c < 0 generates an array of elements a,a-c,a-2c and ends with the number not less than b');
+ equal(_.range(0, -10, -1).join(' '), '0 -1 -2 -3 -4 -5 -6 -7 -8 -9', 'final example in the Python docs');
+ });
+
+});
diff --git a/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/chaining.js b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/chaining.js
new file mode 100644
index 0000000..16cf7bf
--- /dev/null
+++ b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/chaining.js
@@ -0,0 +1,59 @@
+$(document).ready(function() {
+
+ module("Chaining");
+
+ test("map/flatten/reduce", function() {
+ var lyrics = [
+ "I'm a lumberjack and I'm okay",
+ "I sleep all night and I work all day",
+ "He's a lumberjack and he's okay",
+ "He sleeps all night and he works all day"
+ ];
+ var counts = _(lyrics).chain()
+ .map(function(line) { return line.split(''); })
+ .flatten()
+ .reduce(function(hash, l) {
+ hash[l] = hash[l] || 0;
+ hash[l]++;
+ return hash;
+ }, {}).value();
+ ok(counts['a'] == 16 && counts['e'] == 10, 'counted all the letters in the song');
+ });
+
+ test("select/reject/sortBy", function() {
+ var numbers = [1,2,3,4,5,6,7,8,9,10];
+ numbers = _(numbers).chain().select(function(n) {
+ return n % 2 == 0;
+ }).reject(function(n) {
+ return n % 4 == 0;
+ }).sortBy(function(n) {
+ return -n;
+ }).value();
+ equal(numbers.join(', '), "10, 6, 2", "filtered and reversed the numbers");
+ });
+
+ test("select/reject/sortBy in functional style", function() {
+ var numbers = [1,2,3,4,5,6,7,8,9,10];
+ numbers = _.chain(numbers).select(function(n) {
+ return n % 2 == 0;
+ }).reject(function(n) {
+ return n % 4 == 0;
+ }).sortBy(function(n) {
+ return -n;
+ }).value();
+ equal(numbers.join(', '), "10, 6, 2", "filtered and reversed the numbers");
+ });
+
+ test("reverse/concat/unshift/pop/map", function() {
+ var numbers = [1,2,3,4,5];
+ numbers = _(numbers).chain()
+ .reverse()
+ .concat([5, 5, 5])
+ .unshift(17)
+ .pop()
+ .map(function(n){ return n * 2; })
+ .value();
+ equal(numbers.join(', '), "34, 10, 8, 6, 4, 2, 10, 10", 'can chain together array functions.');
+ });
+
+});
diff --git a/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/collections.js b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/collections.js
new file mode 100644
index 0000000..e089626
--- /dev/null
+++ b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/collections.js
@@ -0,0 +1,426 @@
+$(document).ready(function() {
+
+ module("Collections");
+
+ test("each", function() {
+ _.each([1, 2, 3], function(num, i) {
+ equal(num, i + 1, 'each iterators provide value and iteration count');
+ });
+
+ var answers = [];
+ _.each([1, 2, 3], function(num){ answers.push(num * this.multiplier);}, {multiplier : 5});
+ equal(answers.join(', '), '5, 10, 15', 'context object property accessed');
+
+ answers = [];
+ _.forEach([1, 2, 3], function(num){ answers.push(num); });
+ equal(answers.join(', '), '1, 2, 3', 'aliased as "forEach"');
+
+ answers = [];
+ var obj = {one : 1, two : 2, three : 3};
+ obj.constructor.prototype.four = 4;
+ _.each(obj, function(value, key){ answers.push(key); });
+ equal(answers.join(", "), 'one, two, three', 'iterating over objects works, and ignores the object prototype.');
+ delete obj.constructor.prototype.four;
+
+ answer = null;
+ _.each([1, 2, 3], function(num, index, arr){ if (_.include(arr, num)) answer = true; });
+ ok(answer, 'can reference the original collection from inside the iterator');
+
+ answers = 0;
+ _.each(null, function(){ ++answers; });
+ equal(answers, 0, 'handles a null properly');
+ });
+
+ test('map', function() {
+ var doubled = _.map([1, 2, 3], function(num){ return num * 2; });
+ equal(doubled.join(', '), '2, 4, 6', 'doubled numbers');
+
+ doubled = _.collect([1, 2, 3], function(num){ return num * 2; });
+ equal(doubled.join(', '), '2, 4, 6', 'aliased as "collect"');
+
+ var tripled = _.map([1, 2, 3], function(num){ return num * this.multiplier; }, {multiplier : 3});
+ equal(tripled.join(', '), '3, 6, 9', 'tripled numbers with context');
+
+ var doubled = _([1, 2, 3]).map(function(num){ return num * 2; });
+ equal(doubled.join(', '), '2, 4, 6', 'OO-style doubled numbers');
+
+ if (document.querySelectorAll) {
+ var ids = _.map(document.querySelectorAll('#map-test *'), function(n){ return n.id; });
+ deepEqual(ids, ['id1', 'id2'], 'Can use collection methods on NodeLists.');
+ }
+
+ var ids = _.map($('#map-test').children(), function(n){ return n.id; });
+ deepEqual(ids, ['id1', 'id2'], 'Can use collection methods on jQuery Array-likes.');
+
+ var ids = _.map(document.images, function(n){ return n.id; });
+ ok(ids[0] == 'chart_image', 'can use collection methods on HTMLCollections');
+
+ var ifnull = _.map(null, function(){});
+ ok(_.isArray(ifnull) && ifnull.length === 0, 'handles a null properly');
+ });
+
+ test('reduce', function() {
+ var sum = _.reduce([1, 2, 3], function(sum, num){ return sum + num; }, 0);
+ equal(sum, 6, 'can sum up an array');
+
+ var context = {multiplier : 3};
+ sum = _.reduce([1, 2, 3], function(sum, num){ return sum + num * this.multiplier; }, 0, context);
+ equal(sum, 18, 'can reduce with a context object');
+
+ sum = _.inject([1, 2, 3], function(sum, num){ return sum + num; }, 0);
+ equal(sum, 6, 'aliased as "inject"');
+
+ sum = _([1, 2, 3]).reduce(function(sum, num){ return sum + num; }, 0);
+ equal(sum, 6, 'OO-style reduce');
+
+ var sum = _.reduce([1, 2, 3], function(sum, num){ return sum + num; });
+ equal(sum, 6, 'default initial value');
+
+ var ifnull;
+ try {
+ _.reduce(null, function(){});
+ } catch (ex) {
+ ifnull = ex;
+ }
+ ok(ifnull instanceof TypeError, 'handles a null (without inital value) properly');
+
+ ok(_.reduce(null, function(){}, 138) === 138, 'handles a null (with initial value) properly');
+ equal(_.reduce([], function(){}, undefined), undefined, 'undefined can be passed as a special case');
+ raises(function() { _.reduce([], function(){}); }, TypeError, 'throws an error for empty arrays with no initial value');
+ });
+
+ test('reduceRight', function() {
+ var list = _.reduceRight(["foo", "bar", "baz"], function(memo, str){ return memo + str; }, '');
+ equal(list, 'bazbarfoo', 'can perform right folds');
+
+ var list = _.foldr(["foo", "bar", "baz"], function(memo, str){ return memo + str; }, '');
+ equal(list, 'bazbarfoo', 'aliased as "foldr"');
+
+ var list = _.foldr(["foo", "bar", "baz"], function(memo, str){ return memo + str; });
+ equal(list, 'bazbarfoo', 'default initial value');
+
+ var ifnull;
+ try {
+ _.reduceRight(null, function(){});
+ } catch (ex) {
+ ifnull = ex;
+ }
+ ok(ifnull instanceof TypeError, 'handles a null (without inital value) properly');
+
+ var sum = _.reduceRight({a: 1, b: 2, c: 3}, function(sum, num){ return sum + num; });
+ equal(sum, 6, 'default initial value on object');
+
+ ok(_.reduceRight(null, function(){}, 138) === 138, 'handles a null (with initial value) properly');
+
+ equal(_.reduceRight([], function(){}, undefined), undefined, 'undefined can be passed as a special case');
+ raises(function() { _.reduceRight([], function(){}); }, TypeError, 'throws an error for empty arrays with no initial value');
+
+ // Assert that the correct arguments are being passed.
+
+ var args,
+ memo = {},
+ object = {a: 1, b: 2},
+ lastKey = _.keys(object).pop();
+
+ var expected = lastKey == 'a'
+ ? [memo, 1, 'a', object]
+ : [memo, 2, 'b', object];
+
+ _.reduceRight(object, function() {
+ args || (args = _.toArray(arguments));
+ }, memo);
+
+ deepEqual(args, expected);
+
+ // And again, with numeric keys.
+
+ object = {'2': 'a', '1': 'b'};
+ lastKey = _.keys(object).pop();
+ args = null;
+
+ expected = lastKey == '2'
+ ? [memo, 'a', '2', object]
+ : [memo, 'b', '1', object];
+
+ _.reduceRight(object, function() {
+ args || (args = _.toArray(arguments));
+ }, memo);
+
+ deepEqual(args, expected);
+ });
+
+ test('find', function() {
+ var array = [1, 2, 3, 4];
+ strictEqual(_.find(array, function(n) { return n > 2; }), 3, 'should return first found `value`');
+ strictEqual(_.find(array, function() { return false; }), void 0, 'should return `undefined` if `value` is not found');
+ });
+
+ test('detect', function() {
+ var result = _.detect([1, 2, 3], function(num){ return num * 2 == 4; });
+ equal(result, 2, 'found the first "2" and broke the loop');
+ });
+
+ test('select', function() {
+ var evens = _.select([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+ equal(evens.join(', '), '2, 4, 6', 'selected each even number');
+
+ evens = _.filter([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+ equal(evens.join(', '), '2, 4, 6', 'aliased as "filter"');
+ });
+
+ test('reject', function() {
+ var odds = _.reject([1, 2, 3, 4, 5, 6], function(num){ return num % 2 == 0; });
+ equal(odds.join(', '), '1, 3, 5', 'rejected each even number');
+
+ var context = "obj";
+
+ var evens = _.reject([1, 2, 3, 4, 5, 6], function(num){
+ equal(context, "obj");
+ return num % 2 != 0;
+ }, context);
+ equal(evens.join(', '), '2, 4, 6', 'rejected each odd number');
+ });
+
+ test('all', function() {
+ ok(_.all([], _.identity), 'the empty set');
+ ok(_.all([true, true, true], _.identity), 'all true values');
+ ok(!_.all([true, false, true], _.identity), 'one false value');
+ ok(_.all([0, 10, 28], function(num){ return num % 2 == 0; }), 'even numbers');
+ ok(!_.all([0, 11, 28], function(num){ return num % 2 == 0; }), 'an odd number');
+ ok(_.all([1], _.identity) === true, 'cast to boolean - true');
+ ok(_.all([0], _.identity) === false, 'cast to boolean - false');
+ ok(_.every([true, true, true], _.identity), 'aliased as "every"');
+ ok(!_.all([undefined, undefined, undefined], _.identity), 'works with arrays of undefined');
+ });
+
+ test('any', function() {
+ var nativeSome = Array.prototype.some;
+ Array.prototype.some = null;
+ ok(!_.any([]), 'the empty set');
+ ok(!_.any([false, false, false]), 'all false values');
+ ok(_.any([false, false, true]), 'one true value');
+ ok(_.any([null, 0, 'yes', false]), 'a string');
+ ok(!_.any([null, 0, '', false]), 'falsy values');
+ ok(!_.any([1, 11, 29], function(num){ return num % 2 == 0; }), 'all odd numbers');
+ ok(_.any([1, 10, 29], function(num){ return num % 2 == 0; }), 'an even number');
+ ok(_.any([1], _.identity) === true, 'cast to boolean - true');
+ ok(_.any([0], _.identity) === false, 'cast to boolean - false');
+ ok(_.some([false, false, true]), 'aliased as "some"');
+ Array.prototype.some = nativeSome;
+ });
+
+ test('include', function() {
+ ok(_.include([1,2,3], 2), 'two is in the array');
+ ok(!_.include([1,3,9], 2), 'two is not in the array');
+ ok(_.contains({moe:1, larry:3, curly:9}, 3) === true, '_.include on objects checks their values');
+ ok(_([1,2,3]).include(2), 'OO-style include');
+ });
+
+ test('invoke', function() {
+ var list = [[5, 1, 7], [3, 2, 1]];
+ var result = _.invoke(list, 'sort');
+ equal(result[0].join(', '), '1, 5, 7', 'first array sorted');
+ equal(result[1].join(', '), '1, 2, 3', 'second array sorted');
+ });
+
+ test('invoke w/ function reference', function() {
+ var list = [[5, 1, 7], [3, 2, 1]];
+ var result = _.invoke(list, Array.prototype.sort);
+ equal(result[0].join(', '), '1, 5, 7', 'first array sorted');
+ equal(result[1].join(', '), '1, 2, 3', 'second array sorted');
+ });
+
+ // Relevant when using ClojureScript
+ test('invoke when strings have a call method', function() {
+ String.prototype.call = function() {
+ return 42;
+ };
+ var list = [[5, 1, 7], [3, 2, 1]];
+ var s = "foo";
+ equal(s.call(), 42, "call function exists");
+ var result = _.invoke(list, 'sort');
+ equal(result[0].join(', '), '1, 5, 7', 'first array sorted');
+ equal(result[1].join(', '), '1, 2, 3', 'second array sorted');
+ delete String.prototype.call;
+ equal(s.call, undefined, "call function removed");
+ });
+
+ test('pluck', function() {
+ var people = [{name : 'moe', age : 30}, {name : 'curly', age : 50}];
+ equal(_.pluck(people, 'name').join(', '), 'moe, curly', 'pulls names out of objects');
+ });
+
+ test('where', function() {
+ var list = [{a: 1, b: 2}, {a: 2, b: 2}, {a: 1, b: 3}, {a: 1, b: 4}];
+ var result = _.where(list, {a: 1});
+ equal(result.length, 3);
+ equal(result[result.length - 1].b, 4);
+ result = _.where(list, {b: 2});
+ equal(result.length, 2);
+ equal(result[0].a, 1);
+ });
+
+ test('max', function() {
+ equal(3, _.max([1, 2, 3]), 'can perform a regular Math.max');
+
+ var neg = _.max([1, 2, 3], function(num){ return -num; });
+ equal(neg, 1, 'can perform a computation-based max');
+
+ equal(-Infinity, _.max({}), 'Maximum value of an empty object');
+ equal(-Infinity, _.max([]), 'Maximum value of an empty array');
+
+ equal(299999, _.max(_.range(1,300000)), "Maximum value of a too-big array");
+ });
+
+ test('min', function() {
+ equal(1, _.min([1, 2, 3]), 'can perform a regular Math.min');
+
+ var neg = _.min([1, 2, 3], function(num){ return -num; });
+ equal(neg, 3, 'can perform a computation-based min');
+
+ equal(Infinity, _.min({}), 'Minimum value of an empty object');
+ equal(Infinity, _.min([]), 'Minimum value of an empty array');
+
+ var now = new Date(9999999999);
+ var then = new Date(0);
+ equal(_.min([now, then]), then);
+
+ equal(1, _.min(_.range(1,300000)), "Minimum value of a too-big array");
+ });
+
+ test('sortBy', function() {
+ var people = [{name : 'curly', age : 50}, {name : 'moe', age : 30}];
+ people = _.sortBy(people, function(person){ return person.age; });
+ equal(_.pluck(people, 'name').join(', '), 'moe, curly', 'stooges sorted by age');
+
+ var list = [undefined, 4, 1, undefined, 3, 2];
+ equal(_.sortBy(list, _.identity).join(','), '1,2,3,4,,', 'sortBy with undefined values');
+
+ var list = ["one", "two", "three", "four", "five"];
+ var sorted = _.sortBy(list, 'length');
+ equal(sorted.join(' '), 'one two four five three', 'sorted by length');
+
+ function Pair(x, y) {
+ this.x = x;
+ this.y = y;
+ }
+
+ var collection = [
+ new Pair(1, 1), new Pair(1, 2),
+ new Pair(1, 3), new Pair(1, 4),
+ new Pair(1, 5), new Pair(1, 6),
+ new Pair(2, 1), new Pair(2, 2),
+ new Pair(2, 3), new Pair(2, 4),
+ new Pair(2, 5), new Pair(2, 6),
+ new Pair(undefined, 1), new Pair(undefined, 2),
+ new Pair(undefined, 3), new Pair(undefined, 4),
+ new Pair(undefined, 5), new Pair(undefined, 6)
+ ];
+
+ var actual = _.sortBy(collection, function(pair) {
+ return pair.x;
+ });
+
+ deepEqual(actual, collection, 'sortBy should be stable');
+ });
+
+ test('groupBy', function() {
+ var parity = _.groupBy([1, 2, 3, 4, 5, 6], function(num){ return num % 2; });
+ ok('0' in parity && '1' in parity, 'created a group for each value');
+ equal(parity[0].join(', '), '2, 4, 6', 'put each even number in the right group');
+
+ var list = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"];
+ var grouped = _.groupBy(list, 'length');
+ equal(grouped['3'].join(' '), 'one two six ten');
+ equal(grouped['4'].join(' '), 'four five nine');
+ equal(grouped['5'].join(' '), 'three seven eight');
+
+ var context = {};
+ _.groupBy([{}], function(){ ok(this === context); }, context);
+
+ grouped = _.groupBy([4.2, 6.1, 6.4], function(num) {
+ return Math.floor(num) > 4 ? 'hasOwnProperty' : 'constructor';
+ });
+ equal(grouped.constructor.length, 1);
+ equal(grouped.hasOwnProperty.length, 2);
+
+ var array = [{}];
+ _.groupBy(array, function(value, index, obj){ ok(obj === array); });
+ });
+
+ test('countBy', function() {
+ var parity = _.countBy([1, 2, 3, 4, 5], function(num){ return num % 2 == 0; });
+ equal(parity['true'], 2);
+ equal(parity['false'], 3);
+
+ var list = ["one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten"];
+ var grouped = _.countBy(list, 'length');
+ equal(grouped['3'], 4);
+ equal(grouped['4'], 3);
+ equal(grouped['5'], 3);
+
+ var context = {};
+ _.countBy([{}], function(){ ok(this === context); }, context);
+
+ grouped = _.countBy([4.2, 6.1, 6.4], function(num) {
+ return Math.floor(num) > 4 ? 'hasOwnProperty' : 'constructor';
+ });
+ equal(grouped.constructor, 1);
+ equal(grouped.hasOwnProperty, 2);
+
+ var array = [{}];
+ _.countBy(array, function(value, index, obj){ ok(obj === array); });
+ });
+
+ test('sortedIndex', function() {
+ var numbers = [10, 20, 30, 40, 50], num = 35;
+ var indexForNum = _.sortedIndex(numbers, num);
+ equal(indexForNum, 3, '35 should be inserted at index 3');
+
+ var indexFor30 = _.sortedIndex(numbers, 30);
+ equal(indexFor30, 2, '30 should be inserted at index 2');
+
+ var objects = [{x: 10}, {x: 20}, {x: 30}, {x: 40}];
+ var iterator = function(obj){ return obj.x; };
+ strictEqual(_.sortedIndex(objects, {x: 25}, iterator), 2);
+ strictEqual(_.sortedIndex(objects, {x: 35}, 'x'), 3);
+
+ var context = {1: 2, 2: 3, 3: 4};
+ iterator = function(obj){ return this[obj]; };
+ strictEqual(_.sortedIndex([1, 3], 2, iterator, context), 1);
+ });
+
+ test('shuffle', function() {
+ var numbers = _.range(10);
+ var shuffled = _.shuffle(numbers).sort();
+ notStrictEqual(numbers, shuffled, 'original object is unmodified');
+ equal(shuffled.join(','), numbers.join(','), 'contains the same members before and after shuffle');
+ });
+
+ test('toArray', function() {
+ ok(!_.isArray(arguments), 'arguments object is not an array');
+ ok(_.isArray(_.toArray(arguments)), 'arguments object converted into array');
+ var a = [1,2,3];
+ ok(_.toArray(a) !== a, 'array is cloned');
+ equal(_.toArray(a).join(', '), '1, 2, 3', 'cloned array contains same elements');
+
+ var numbers = _.toArray({one : 1, two : 2, three : 3});
+ equal(numbers.join(', '), '1, 2, 3', 'object flattened into array');
+ });
+
+ test('size', function() {
+ equal(_.size({one : 1, two : 2, three : 3}), 3, 'can compute the size of an object');
+ equal(_.size([1, 2, 3]), 3, 'can compute the size of an array');
+
+ var func = function() {
+ return _.size(arguments);
+ };
+
+ equal(func(1, 2, 3, 4), 4, 'can test the size of the arguments object');
+
+ equal(_.size('hello'), 5, 'can compute the size of a string');
+
+ equal(_.size(null), 0, 'handles nulls');
+ });
+
+});
diff --git a/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/functions.js b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/functions.js
new file mode 100644
index 0000000..a529658
--- /dev/null
+++ b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/functions.js
@@ -0,0 +1,259 @@
+$(document).ready(function() {
+
+ module("Functions");
+
+ test("bind", function() {
+ var context = {name : 'moe'};
+ var func = function(arg) { return "name: " + (this.name || arg); };
+ var bound = _.bind(func, context);
+ equal(bound(), 'name: moe', 'can bind a function to a context');
+
+ bound = _(func).bind(context);
+ equal(bound(), 'name: moe', 'can do OO-style binding');
+
+ bound = _.bind(func, null, 'curly');
+ equal(bound(), 'name: curly', 'can bind without specifying a context');
+
+ func = function(salutation, name) { return salutation + ': ' + name; };
+ func = _.bind(func, this, 'hello');
+ equal(func('moe'), 'hello: moe', 'the function was partially applied in advance');
+
+ var func = _.bind(func, this, 'curly');
+ equal(func(), 'hello: curly', 'the function was completely applied in advance');
+
+ var func = function(salutation, firstname, lastname) { return salutation + ': ' + firstname + ' ' + lastname; };
+ func = _.bind(func, this, 'hello', 'moe', 'curly');
+ equal(func(), 'hello: moe curly', 'the function was partially applied in advance and can accept multiple arguments');
+
+ func = function(context, message) { equal(this, context, message); };
+ _.bind(func, 0, 0, 'can bind a function to `0`')();
+ _.bind(func, '', '', 'can bind a function to an empty string')();
+ _.bind(func, false, false, 'can bind a function to `false`')();
+
+ // These tests are only meaningful when using a browser without a native bind function
+ // To test this with a modern browser, set underscore's nativeBind to undefined
+ var F = function () { return this; };
+ var Boundf = _.bind(F, {hello: "moe curly"});
+ equal(new Boundf().hello, undefined, "function should not be bound to the context, to comply with ECMAScript 5");
+ equal(Boundf().hello, "moe curly", "When called without the new operator, it's OK to be bound to the context");
+ });
+
+ test("bindAll", function() {
+ var curly = {name : 'curly'}, moe = {
+ name : 'moe',
+ getName : function() { return 'name: ' + this.name; },
+ sayHi : function() { return 'hi: ' + this.name; }
+ };
+ curly.getName = moe.getName;
+ _.bindAll(moe, 'getName', 'sayHi');
+ curly.sayHi = moe.sayHi;
+ equal(curly.getName(), 'name: curly', 'unbound function is bound to current object');
+ equal(curly.sayHi(), 'hi: moe', 'bound function is still bound to original object');
+
+ curly = {name : 'curly'};
+ moe = {
+ name : 'moe',
+ getName : function() { return 'name: ' + this.name; },
+ sayHi : function() { return 'hi: ' + this.name; }
+ };
+ _.bindAll(moe);
+ curly.sayHi = moe.sayHi;
+ equal(curly.sayHi(), 'hi: moe', 'calling bindAll with no arguments binds all functions to the object');
+ });
+
+ test("memoize", function() {
+ var fib = function(n) {
+ return n < 2 ? n : fib(n - 1) + fib(n - 2);
+ };
+ var fastFib = _.memoize(fib);
+ equal(fib(10), 55, 'a memoized version of fibonacci produces identical results');
+ equal(fastFib(10), 55, 'a memoized version of fibonacci produces identical results');
+
+ var o = function(str) {
+ return str;
+ };
+ var fastO = _.memoize(o);
+ equal(o('toString'), 'toString', 'checks hasOwnProperty');
+ equal(fastO('toString'), 'toString', 'checks hasOwnProperty');
+ });
+
+ asyncTest("delay", 2, function() {
+ var delayed = false;
+ _.delay(function(){ delayed = true; }, 100);
+ setTimeout(function(){ ok(!delayed, "didn't delay the function quite yet"); }, 50);
+ setTimeout(function(){ ok(delayed, 'delayed the function'); start(); }, 150);
+ });
+
+ asyncTest("defer", 1, function() {
+ var deferred = false;
+ _.defer(function(bool){ deferred = bool; }, true);
+ _.delay(function(){ ok(deferred, "deferred the function"); start(); }, 50);
+ });
+
+ asyncTest("throttle", 2, function() {
+ var counter = 0;
+ var incr = function(){ counter++; };
+ var throttledIncr = _.throttle(incr, 100);
+ throttledIncr(); throttledIncr(); throttledIncr();
+ setTimeout(throttledIncr, 70);
+ setTimeout(throttledIncr, 120);
+ setTimeout(throttledIncr, 140);
+ setTimeout(throttledIncr, 190);
+ setTimeout(throttledIncr, 220);
+ setTimeout(throttledIncr, 240);
+ _.delay(function(){ equal(counter, 1, "incr was called immediately"); }, 30);
+ _.delay(function(){ equal(counter, 4, "incr was throttled"); start(); }, 400);
+ });
+
+ asyncTest("throttle arguments", 2, function() {
+ var value = 0;
+ var update = function(val){ value = val; };
+ var throttledUpdate = _.throttle(update, 100);
+ throttledUpdate(1); throttledUpdate(2); throttledUpdate(3);
+ setTimeout(function(){ throttledUpdate(4); }, 120);
+ setTimeout(function(){ throttledUpdate(5); }, 140);
+ setTimeout(function(){ throttledUpdate(6); }, 250);
+ _.delay(function(){ equal(value, 1, "updated to latest value"); }, 40);
+ _.delay(function(){ equal(value, 6, "updated to latest value"); start(); }, 400);
+ });
+
+ asyncTest("throttle once", 2, function() {
+ var counter = 0;
+ var incr = function(){ return ++counter; };
+ var throttledIncr = _.throttle(incr, 100);
+ var result = throttledIncr();
+ _.delay(function(){
+ equal(result, 1, "throttled functions return their value");
+ equal(counter, 1, "incr was called once"); start();
+ }, 220);
+ });
+
+ asyncTest("throttle twice", 1, function() {
+ var counter = 0;
+ var incr = function(){ counter++; };
+ var throttledIncr = _.throttle(incr, 100);
+ throttledIncr(); throttledIncr();
+ _.delay(function(){ equal(counter, 2, "incr was called twice"); start(); }, 220);
+ });
+
+ asyncTest("throttle repeatedly with results", 9, function() {
+ var counter = 0;
+ var incr = function(){ return ++counter; };
+ var throttledIncr = _.throttle(incr, 100);
+ var results = [];
+ var saveResult = function() { results.push(throttledIncr()); };
+ saveResult(); saveResult(); saveResult();
+ setTimeout(saveResult, 70);
+ setTimeout(saveResult, 120);
+ setTimeout(saveResult, 140);
+ setTimeout(saveResult, 190);
+ setTimeout(saveResult, 240);
+ setTimeout(saveResult, 260);
+ _.delay(function() {
+ equal(results[0], 1, "incr was called once");
+ equal(results[1], 1, "incr was throttled");
+ equal(results[2], 1, "incr was throttled");
+ equal(results[3], 1, "incr was throttled");
+ equal(results[4], 2, "incr was called twice");
+ equal(results[5], 2, "incr was throttled");
+ equal(results[6], 2, "incr was throttled");
+ equal(results[7], 3, "incr was called thrice");
+ equal(results[8], 3, "incr was throttled");
+ start();
+ }, 400);
+ });
+
+ asyncTest("debounce", 1, function() {
+ var counter = 0;
+ var incr = function(){ counter++; };
+ var debouncedIncr = _.debounce(incr, 50);
+ debouncedIncr(); debouncedIncr(); debouncedIncr();
+ setTimeout(debouncedIncr, 30);
+ setTimeout(debouncedIncr, 60);
+ setTimeout(debouncedIncr, 90);
+ setTimeout(debouncedIncr, 120);
+ setTimeout(debouncedIncr, 150);
+ _.delay(function(){ equal(counter, 1, "incr was debounced"); start(); }, 220);
+ });
+
+ asyncTest("debounce asap", 5, function() {
+ var a, b, c;
+ var counter = 0;
+ var incr = function(){ return ++counter; };
+ var debouncedIncr = _.debounce(incr, 50, true);
+ a = debouncedIncr();
+ b = debouncedIncr();
+ c = debouncedIncr();
+ equal(a, 1);
+ equal(b, 1);
+ equal(c, 1);
+ equal(counter, 1, 'incr was called immediately');
+ setTimeout(debouncedIncr, 30);
+ setTimeout(debouncedIncr, 60);
+ setTimeout(debouncedIncr, 90);
+ setTimeout(debouncedIncr, 120);
+ setTimeout(debouncedIncr, 150);
+ _.delay(function(){ equal(counter, 1, "incr was debounced"); start(); }, 220);
+ });
+
+ asyncTest("debounce asap recursively", 2, function() {
+ var counter = 0;
+ var debouncedIncr = _.debounce(function(){
+ counter++;
+ if (counter < 5) debouncedIncr();
+ }, 50, true);
+ debouncedIncr();
+ equal(counter, 1, 'incr was called immediately');
+ _.delay(function(){ equal(counter, 1, "incr was debounced"); start(); }, 70);
+ });
+
+ test("once", function() {
+ var num = 0;
+ var increment = _.once(function(){ num++; });
+ increment();
+ increment();
+ equal(num, 1);
+ });
+
+ test("wrap", function() {
+ var greet = function(name){ return "hi: " + name; };
+ var backwards = _.wrap(greet, function(func, name){ return func(name) + ' ' + name.split('').reverse().join(''); });
+ equal(backwards('moe'), 'hi: moe eom', 'wrapped the saluation function');
+
+ var inner = function(){ return "Hello "; };
+ var obj = {name : "Moe"};
+ obj.hi = _.wrap(inner, function(fn){ return fn() + this.name; });
+ equal(obj.hi(), "Hello Moe");
+
+ var noop = function(){};
+ var wrapped = _.wrap(noop, function(fn){ return Array.prototype.slice.call(arguments, 0); });
+ var ret = wrapped(['whats', 'your'], 'vector', 'victor');
+ deepEqual(ret, [noop, ['whats', 'your'], 'vector', 'victor']);
+ });
+
+ test("compose", function() {
+ var greet = function(name){ return "hi: " + name; };
+ var exclaim = function(sentence){ return sentence + '!'; };
+ var composed = _.compose(exclaim, greet);
+ equal(composed('moe'), 'hi: moe!', 'can compose a function that takes another');
+
+ composed = _.compose(greet, exclaim);
+ equal(composed('moe'), 'hi: moe!', 'in this case, the functions are also commutative');
+ });
+
+ test("after", function() {
+ var testAfter = function(afterAmount, timesCalled) {
+ var afterCalled = 0;
+ var after = _.after(afterAmount, function() {
+ afterCalled++;
+ });
+ while (timesCalled--) after();
+ return afterCalled;
+ };
+
+ equal(testAfter(5, 5), 1, "after(N) should fire after being called N times");
+ equal(testAfter(5, 4), 0, "after(N) should not fire unless called N times");
+ equal(testAfter(0, 0), 1, "after(0) should fire immediately");
+ });
+
+});
diff --git a/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/index.html b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/index.html
new file mode 100644
index 0000000..064fa98
--- /dev/null
+++ b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/index.html
@@ -0,0 +1,45 @@
+
+
+
+ Underscore Test Suite
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ A representative sample of the functions are benchmarked here, to provide
+ a sense of how fast they might run in different browsers.
+ Each iteration runs on an array of 1000 elements.
+ For example, the 'intersection' test measures the number of times you can
+ find the intersection of two thousand-element arrays in one second.
+
+
+
+
+
diff --git a/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/objects.js b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/objects.js
new file mode 100644
index 0000000..22949c3
--- /dev/null
+++ b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/objects.js
@@ -0,0 +1,548 @@
+$(document).ready(function() {
+
+ module("Objects");
+
+ test("keys", function() {
+ equal(_.keys({one : 1, two : 2}).join(', '), 'one, two', 'can extract the keys from an object');
+ // the test above is not safe because it relies on for-in enumeration order
+ var a = []; a[1] = 0;
+ equal(_.keys(a).join(', '), '1', 'is not fooled by sparse arrays; see issue #95');
+ raises(function() { _.keys(null); }, TypeError, 'throws an error for `null` values');
+ raises(function() { _.keys(void 0); }, TypeError, 'throws an error for `undefined` values');
+ raises(function() { _.keys(1); }, TypeError, 'throws an error for number primitives');
+ raises(function() { _.keys('a'); }, TypeError, 'throws an error for string primitives');
+ raises(function() { _.keys(true); }, TypeError, 'throws an error for boolean primitives');
+ });
+
+ test("values", function() {
+ equal(_.values({one: 1, two: 2}).join(', '), '1, 2', 'can extract the values from an object');
+ equal(_.values({one: 1, two: 2, length: 3}).join(', '), '1, 2, 3', '... even when one of them is "length"');
+ });
+
+ test("pairs", function() {
+ deepEqual(_.pairs({one: 1, two: 2}), [['one', 1], ['two', 2]], 'can convert an object into pairs');
+ deepEqual(_.pairs({one: 1, two: 2, length: 3}), [['one', 1], ['two', 2], ['length', 3]], '... even when one of them is "length"');
+ });
+
+ test("invert", function() {
+ var obj = {first: 'Moe', second: 'Larry', third: 'Curly'};
+ equal(_.keys(_.invert(obj)).join(' '), 'Moe Larry Curly', 'can invert an object');
+ ok(_.isEqual(_.invert(_.invert(obj)), obj), 'two inverts gets you back where you started');
+
+ var obj = {length: 3};
+ ok(_.invert(obj)['3'] == 'length', 'can invert an object with "length"')
+ });
+
+ test("functions", function() {
+ var obj = {a : 'dash', b : _.map, c : (/yo/), d : _.reduce};
+ ok(_.isEqual(['b', 'd'], _.functions(obj)), 'can grab the function names of any passed-in object');
+
+ var Animal = function(){};
+ Animal.prototype.run = function(){};
+ equal(_.functions(new Animal).join(''), 'run', 'also looks up functions on the prototype');
+ });
+
+ test("extend", function() {
+ var result;
+ equal(_.extend({}, {a:'b'}).a, 'b', 'can extend an object with the attributes of another');
+ equal(_.extend({a:'x'}, {a:'b'}).a, 'b', 'properties in source override destination');
+ equal(_.extend({x:'x'}, {a:'b'}).x, 'x', 'properties not in source dont get overriden');
+ result = _.extend({x:'x'}, {a:'a'}, {b:'b'});
+ ok(_.isEqual(result, {x:'x', a:'a', b:'b'}), 'can extend from multiple source objects');
+ result = _.extend({x:'x'}, {a:'a', x:2}, {a:'b'});
+ ok(_.isEqual(result, {x:2, a:'b'}), 'extending from multiple source objects last property trumps');
+ result = _.extend({}, {a: void 0, b: null});
+ equal(_.keys(result).join(''), 'ab', 'extend does not copy undefined values');
+ });
+
+ test("pick", function() {
+ var result;
+ result = _.pick({a:1, b:2, c:3}, 'a', 'c');
+ ok(_.isEqual(result, {a:1, c:3}), 'can restrict properties to those named');
+ result = _.pick({a:1, b:2, c:3}, ['b', 'c']);
+ ok(_.isEqual(result, {b:2, c:3}), 'can restrict properties to those named in an array');
+ result = _.pick({a:1, b:2, c:3}, ['a'], 'b');
+ ok(_.isEqual(result, {a:1, b:2}), 'can restrict properties to those named in mixed args');
+
+ var Obj = function(){};
+ Obj.prototype = {a: 1, b: 2, c: 3};
+ ok(_.isEqual(_.pick(new Obj, 'a', 'c'), {a:1, c: 3}), 'include prototype props');
+ });
+
+ test("omit", function() {
+ var result;
+ result = _.omit({a:1, b:2, c:3}, 'b');
+ ok(_.isEqual(result, {a:1, c:3}), 'can omit a single named property');
+ result = _.omit({a:1, b:2, c:3}, 'a', 'c');
+ ok(_.isEqual(result, {b:2}), 'can omit several named properties');
+ result = _.omit({a:1, b:2, c:3}, ['b', 'c']);
+ ok(_.isEqual(result, {a:1}), 'can omit properties named in an array');
+
+ var Obj = function(){};
+ Obj.prototype = {a: 1, b: 2, c: 3};
+ ok(_.isEqual(_.omit(new Obj, 'b'), {a:1, c: 3}), 'include prototype props');
+ });
+
+ test("defaults", function() {
+ var result;
+ var options = {zero: 0, one: 1, empty: "", nan: NaN, string: "string"};
+
+ _.defaults(options, {zero: 1, one: 10, twenty: 20});
+ equal(options.zero, 0, 'value exists');
+ equal(options.one, 1, 'value exists');
+ equal(options.twenty, 20, 'default applied');
+
+ _.defaults(options, {empty: "full"}, {nan: "nan"}, {word: "word"}, {word: "dog"});
+ equal(options.empty, "", 'value exists');
+ ok(_.isNaN(options.nan), "NaN isn't overridden");
+ equal(options.word, "word", 'new value is added, first one wins');
+ });
+
+ test("clone", function() {
+ var moe = {name : 'moe', lucky : [13, 27, 34]};
+ var clone = _.clone(moe);
+ equal(clone.name, 'moe', 'the clone as the attributes of the original');
+
+ clone.name = 'curly';
+ ok(clone.name == 'curly' && moe.name == 'moe', 'clones can change shallow attributes without affecting the original');
+
+ clone.lucky.push(101);
+ equal(_.last(moe.lucky), 101, 'changes to deep attributes are shared with the original');
+
+ equal(_.clone(undefined), void 0, 'non objects should not be changed by clone');
+ equal(_.clone(1), 1, 'non objects should not be changed by clone');
+ equal(_.clone(null), null, 'non objects should not be changed by clone');
+ });
+
+ test("isEqual", function() {
+ function First() {
+ this.value = 1;
+ }
+ First.prototype.value = 1;
+ function Second() {
+ this.value = 1;
+ }
+ Second.prototype.value = 2;
+
+ // Basic equality and identity comparisons.
+ ok(_.isEqual(null, null), "`null` is equal to `null`");
+ ok(_.isEqual(), "`undefined` is equal to `undefined`");
+
+ ok(!_.isEqual(0, -0), "`0` is not equal to `-0`");
+ ok(!_.isEqual(-0, 0), "Commutative equality is implemented for `0` and `-0`");
+ ok(!_.isEqual(null, undefined), "`null` is not equal to `undefined`");
+ ok(!_.isEqual(undefined, null), "Commutative equality is implemented for `null` and `undefined`");
+
+ // String object and primitive comparisons.
+ ok(_.isEqual("Curly", "Curly"), "Identical string primitives are equal");
+ ok(_.isEqual(new String("Curly"), new String("Curly")), "String objects with identical primitive values are equal");
+ ok(_.isEqual(new String("Curly"), "Curly"), "String primitives and their corresponding object wrappers are equal");
+ ok(_.isEqual("Curly", new String("Curly")), "Commutative equality is implemented for string objects and primitives");
+
+ ok(!_.isEqual("Curly", "Larry"), "String primitives with different values are not equal");
+ ok(!_.isEqual(new String("Curly"), new String("Larry")), "String objects with different primitive values are not equal");
+ ok(!_.isEqual(new String("Curly"), {toString: function(){ return "Curly"; }}), "String objects and objects with a custom `toString` method are not equal");
+
+ // Number object and primitive comparisons.
+ ok(_.isEqual(75, 75), "Identical number primitives are equal");
+ ok(_.isEqual(new Number(75), new Number(75)), "Number objects with identical primitive values are equal");
+ ok(_.isEqual(75, new Number(75)), "Number primitives and their corresponding object wrappers are equal");
+ ok(_.isEqual(new Number(75), 75), "Commutative equality is implemented for number objects and primitives");
+ ok(!_.isEqual(new Number(0), -0), "`new Number(0)` and `-0` are not equal");
+ ok(!_.isEqual(0, new Number(-0)), "Commutative equality is implemented for `new Number(0)` and `-0`");
+
+ ok(!_.isEqual(new Number(75), new Number(63)), "Number objects with different primitive values are not equal");
+ ok(!_.isEqual(new Number(63), {valueOf: function(){ return 63; }}), "Number objects and objects with a `valueOf` method are not equal");
+
+ // Comparisons involving `NaN`.
+ ok(_.isEqual(NaN, NaN), "`NaN` is equal to `NaN`");
+ ok(!_.isEqual(61, NaN), "A number primitive is not equal to `NaN`");
+ ok(!_.isEqual(new Number(79), NaN), "A number object is not equal to `NaN`");
+ ok(!_.isEqual(Infinity, NaN), "`Infinity` is not equal to `NaN`");
+
+ // Boolean object and primitive comparisons.
+ ok(_.isEqual(true, true), "Identical boolean primitives are equal");
+ ok(_.isEqual(new Boolean, new Boolean), "Boolean objects with identical primitive values are equal");
+ ok(_.isEqual(true, new Boolean(true)), "Boolean primitives and their corresponding object wrappers are equal");
+ ok(_.isEqual(new Boolean(true), true), "Commutative equality is implemented for booleans");
+ ok(!_.isEqual(new Boolean(true), new Boolean), "Boolean objects with different primitive values are not equal");
+
+ // Common type coercions.
+ ok(!_.isEqual(true, new Boolean(false)), "Boolean objects are not equal to the boolean primitive `true`");
+ ok(!_.isEqual("75", 75), "String and number primitives with like values are not equal");
+ ok(!_.isEqual(new Number(63), new String(63)), "String and number objects with like values are not equal");
+ ok(!_.isEqual(75, "75"), "Commutative equality is implemented for like string and number values");
+ ok(!_.isEqual(0, ""), "Number and string primitives with like values are not equal");
+ ok(!_.isEqual(1, true), "Number and boolean primitives with like values are not equal");
+ ok(!_.isEqual(new Boolean(false), new Number(0)), "Boolean and number objects with like values are not equal");
+ ok(!_.isEqual(false, new String("")), "Boolean primitives and string objects with like values are not equal");
+ ok(!_.isEqual(12564504e5, new Date(2009, 9, 25)), "Dates and their corresponding numeric primitive values are not equal");
+
+ // Dates.
+ ok(_.isEqual(new Date(2009, 9, 25), new Date(2009, 9, 25)), "Date objects referencing identical times are equal");
+ ok(!_.isEqual(new Date(2009, 9, 25), new Date(2009, 11, 13)), "Date objects referencing different times are not equal");
+ ok(!_.isEqual(new Date(2009, 11, 13), {
+ getTime: function(){
+ return 12606876e5;
+ }
+ }), "Date objects and objects with a `getTime` method are not equal");
+ ok(!_.isEqual(new Date("Curly"), new Date("Curly")), "Invalid dates are not equal");
+
+ // Functions.
+ ok(!_.isEqual(First, Second), "Different functions with identical bodies and source code representations are not equal");
+
+ // RegExps.
+ ok(_.isEqual(/(?:)/gim, /(?:)/gim), "RegExps with equivalent patterns and flags are equal");
+ ok(!_.isEqual(/(?:)/g, /(?:)/gi), "RegExps with equivalent patterns and different flags are not equal");
+ ok(!_.isEqual(/Moe/gim, /Curly/gim), "RegExps with different patterns and equivalent flags are not equal");
+ ok(!_.isEqual(/(?:)/gi, /(?:)/g), "Commutative equality is implemented for RegExps");
+ ok(!_.isEqual(/Curly/g, {source: "Larry", global: true, ignoreCase: false, multiline: false}), "RegExps and RegExp-like objects are not equal");
+
+ // Empty arrays, array-like objects, and object literals.
+ ok(_.isEqual({}, {}), "Empty object literals are equal");
+ ok(_.isEqual([], []), "Empty array literals are equal");
+ ok(_.isEqual([{}], [{}]), "Empty nested arrays and objects are equal");
+ ok(!_.isEqual({length: 0}, []), "Array-like objects and arrays are not equal.");
+ ok(!_.isEqual([], {length: 0}), "Commutative equality is implemented for array-like objects");
+
+ ok(!_.isEqual({}, []), "Object literals and array literals are not equal");
+ ok(!_.isEqual([], {}), "Commutative equality is implemented for objects and arrays");
+
+ // Arrays with primitive and object values.
+ ok(_.isEqual([1, "Larry", true], [1, "Larry", true]), "Arrays containing identical primitives are equal");
+ ok(_.isEqual([(/Moe/g), new Date(2009, 9, 25)], [(/Moe/g), new Date(2009, 9, 25)]), "Arrays containing equivalent elements are equal");
+
+ // Multi-dimensional arrays.
+ var a = [new Number(47), false, "Larry", /Moe/, new Date(2009, 11, 13), ['running', 'biking', new String('programming')], {a: 47}];
+ var b = [new Number(47), false, "Larry", /Moe/, new Date(2009, 11, 13), ['running', 'biking', new String('programming')], {a: 47}];
+ ok(_.isEqual(a, b), "Arrays containing nested arrays and objects are recursively compared");
+
+ // Overwrite the methods defined in ES 5.1 section 15.4.4.
+ a.forEach = a.map = a.filter = a.every = a.indexOf = a.lastIndexOf = a.some = a.reduce = a.reduceRight = null;
+ b.join = b.pop = b.reverse = b.shift = b.slice = b.splice = b.concat = b.sort = b.unshift = null;
+
+ // Array elements and properties.
+ ok(_.isEqual(a, b), "Arrays containing equivalent elements and different non-numeric properties are equal");
+ a.push("White Rocks");
+ ok(!_.isEqual(a, b), "Arrays of different lengths are not equal");
+ a.push("East Boulder");
+ b.push("Gunbarrel Ranch", "Teller Farm");
+ ok(!_.isEqual(a, b), "Arrays of identical lengths containing different elements are not equal");
+
+ // Sparse arrays.
+ ok(_.isEqual(Array(3), Array(3)), "Sparse arrays of identical lengths are equal");
+ ok(!_.isEqual(Array(3), Array(6)), "Sparse arrays of different lengths are not equal when both are empty");
+
+ // Simple objects.
+ ok(_.isEqual({a: "Curly", b: 1, c: true}, {a: "Curly", b: 1, c: true}), "Objects containing identical primitives are equal");
+ ok(_.isEqual({a: /Curly/g, b: new Date(2009, 11, 13)}, {a: /Curly/g, b: new Date(2009, 11, 13)}), "Objects containing equivalent members are equal");
+ ok(!_.isEqual({a: 63, b: 75}, {a: 61, b: 55}), "Objects of identical sizes with different values are not equal");
+ ok(!_.isEqual({a: 63, b: 75}, {a: 61, c: 55}), "Objects of identical sizes with different property names are not equal");
+ ok(!_.isEqual({a: 1, b: 2}, {a: 1}), "Objects of different sizes are not equal");
+ ok(!_.isEqual({a: 1}, {a: 1, b: 2}), "Commutative equality is implemented for objects");
+ ok(!_.isEqual({x: 1, y: undefined}, {x: 1, z: 2}), "Objects with identical keys and different values are not equivalent");
+
+ // `A` contains nested objects and arrays.
+ a = {
+ name: new String("Moe Howard"),
+ age: new Number(77),
+ stooge: true,
+ hobbies: ["acting"],
+ film: {
+ name: "Sing a Song of Six Pants",
+ release: new Date(1947, 9, 30),
+ stars: [new String("Larry Fine"), "Shemp Howard"],
+ minutes: new Number(16),
+ seconds: 54
+ }
+ };
+
+ // `B` contains equivalent nested objects and arrays.
+ b = {
+ name: new String("Moe Howard"),
+ age: new Number(77),
+ stooge: true,
+ hobbies: ["acting"],
+ film: {
+ name: "Sing a Song of Six Pants",
+ release: new Date(1947, 9, 30),
+ stars: [new String("Larry Fine"), "Shemp Howard"],
+ minutes: new Number(16),
+ seconds: 54
+ }
+ };
+ ok(_.isEqual(a, b), "Objects with nested equivalent members are recursively compared");
+
+ // Instances.
+ ok(_.isEqual(new First, new First), "Object instances are equal");
+ ok(!_.isEqual(new First, new Second), "Objects with different constructors and identical own properties are not equal");
+ ok(!_.isEqual({value: 1}, new First), "Object instances and objects sharing equivalent properties are not equal");
+ ok(!_.isEqual({value: 2}, new Second), "The prototype chain of objects should not be examined");
+
+ // Circular Arrays.
+ (a = []).push(a);
+ (b = []).push(b);
+ ok(_.isEqual(a, b), "Arrays containing circular references are equal");
+ a.push(new String("Larry"));
+ b.push(new String("Larry"));
+ ok(_.isEqual(a, b), "Arrays containing circular references and equivalent properties are equal");
+ a.push("Shemp");
+ b.push("Curly");
+ ok(!_.isEqual(a, b), "Arrays containing circular references and different properties are not equal");
+
+ // More circular arrays #767.
+ a = ["everything is checked but", "this", "is not"];
+ a[1] = a;
+ b = ["everything is checked but", ["this", "array"], "is not"];
+ ok(!_.isEqual(a, b), "Comparison of circular references with non-circular references are not equal");
+
+ // Circular Objects.
+ a = {abc: null};
+ b = {abc: null};
+ a.abc = a;
+ b.abc = b;
+ ok(_.isEqual(a, b), "Objects containing circular references are equal");
+ a.def = 75;
+ b.def = 75;
+ ok(_.isEqual(a, b), "Objects containing circular references and equivalent properties are equal");
+ a.def = new Number(75);
+ b.def = new Number(63);
+ ok(!_.isEqual(a, b), "Objects containing circular references and different properties are not equal");
+
+ // More circular objects #767.
+ a = {everything: "is checked", but: "this", is: "not"};
+ a.but = a;
+ b = {everything: "is checked", but: {that:"object"}, is: "not"};
+ ok(!_.isEqual(a, b), "Comparison of circular references with non-circular object references are not equal");
+
+ // Cyclic Structures.
+ a = [{abc: null}];
+ b = [{abc: null}];
+ (a[0].abc = a).push(a);
+ (b[0].abc = b).push(b);
+ ok(_.isEqual(a, b), "Cyclic structures are equal");
+ a[0].def = "Larry";
+ b[0].def = "Larry";
+ ok(_.isEqual(a, b), "Cyclic structures containing equivalent properties are equal");
+ a[0].def = new String("Larry");
+ b[0].def = new String("Curly");
+ ok(!_.isEqual(a, b), "Cyclic structures containing different properties are not equal");
+
+ // Complex Circular References.
+ a = {foo: {b: {foo: {c: {foo: null}}}}};
+ b = {foo: {b: {foo: {c: {foo: null}}}}};
+ a.foo.b.foo.c.foo = a;
+ b.foo.b.foo.c.foo = b;
+ ok(_.isEqual(a, b), "Cyclic structures with nested and identically-named properties are equal");
+
+ // Chaining.
+ ok(!_.isEqual(_({x: 1, y: undefined}).chain(), _({x: 1, z: 2}).chain()), 'Chained objects containing different values are not equal');
+ equal(_({x: 1, y: 2}).chain().isEqual(_({x: 1, y: 2}).chain()).value(), true, '`isEqual` can be chained');
+
+ // Custom `isEqual` methods.
+ var isEqualObj = {isEqual: function (o) { return o.isEqual == this.isEqual; }, unique: {}};
+ var isEqualObjClone = {isEqual: isEqualObj.isEqual, unique: {}};
+
+ ok(_.isEqual(isEqualObj, isEqualObjClone), 'Both objects implement identical `isEqual` methods');
+ ok(_.isEqual(isEqualObjClone, isEqualObj), 'Commutative equality is implemented for objects with custom `isEqual` methods');
+ ok(!_.isEqual(isEqualObj, {}), 'Objects that do not implement equivalent `isEqual` methods are not equal');
+ ok(!_.isEqual({}, isEqualObj), 'Commutative equality is implemented for objects with different `isEqual` methods');
+
+ // Objects from another frame.
+ ok(_.isEqual({}, iObject));
+ });
+
+ test("isEmpty", function() {
+ ok(!_([1]).isEmpty(), '[1] is not empty');
+ ok(_.isEmpty([]), '[] is empty');
+ ok(!_.isEmpty({one : 1}), '{one : 1} is not empty');
+ ok(_.isEmpty({}), '{} is empty');
+ ok(_.isEmpty(new RegExp('')), 'objects with prototype properties are empty');
+ ok(_.isEmpty(null), 'null is empty');
+ ok(_.isEmpty(), 'undefined is empty');
+ ok(_.isEmpty(''), 'the empty string is empty');
+ ok(!_.isEmpty('moe'), 'but other strings are not');
+
+ var obj = {one : 1};
+ delete obj.one;
+ ok(_.isEmpty(obj), 'deleting all the keys from an object empties it');
+ });
+
+ // Setup remote variables for iFrame tests.
+ var iframe = document.createElement('iframe');
+ jQuery(iframe).appendTo(document.body);
+ var iDoc = iframe.contentDocument || iframe.contentWindow.document;
+ iDoc.write(
+ ""
+ );
+ iDoc.close();
+
+ test("isElement", function() {
+ ok(!_.isElement('div'), 'strings are not dom elements');
+ ok(_.isElement($('html')[0]), 'the html tag is a DOM element');
+ ok(_.isElement(iElement), 'even from another frame');
+ });
+
+ test("isArguments", function() {
+ var args = (function(){ return arguments; })(1, 2, 3);
+ ok(!_.isArguments('string'), 'a string is not an arguments object');
+ ok(!_.isArguments(_.isArguments), 'a function is not an arguments object');
+ ok(_.isArguments(args), 'but the arguments object is an arguments object');
+ ok(!_.isArguments(_.toArray(args)), 'but not when it\'s converted into an array');
+ ok(!_.isArguments([1,2,3]), 'and not vanilla arrays.');
+ ok(_.isArguments(iArguments), 'even from another frame');
+ });
+
+ test("isObject", function() {
+ ok(_.isObject(arguments), 'the arguments object is object');
+ ok(_.isObject([1, 2, 3]), 'and arrays');
+ ok(_.isObject($('html')[0]), 'and DOM element');
+ ok(_.isObject(iElement), 'even from another frame');
+ ok(_.isObject(function () {}), 'and functions');
+ ok(_.isObject(iFunction), 'even from another frame');
+ ok(!_.isObject(null), 'but not null');
+ ok(!_.isObject(undefined), 'and not undefined');
+ ok(!_.isObject('string'), 'and not string');
+ ok(!_.isObject(12), 'and not number');
+ ok(!_.isObject(true), 'and not boolean');
+ ok(_.isObject(new String('string')), 'but new String()');
+ });
+
+ test("isArray", function() {
+ ok(!_.isArray(arguments), 'the arguments object is not an array');
+ ok(_.isArray([1, 2, 3]), 'but arrays are');
+ ok(_.isArray(iArray), 'even from another frame');
+ });
+
+ test("isString", function() {
+ ok(!_.isString(document.body), 'the document body is not a string');
+ ok(_.isString([1, 2, 3].join(', ')), 'but strings are');
+ ok(_.isString(iString), 'even from another frame');
+ });
+
+ test("isNumber", function() {
+ ok(!_.isNumber('string'), 'a string is not a number');
+ ok(!_.isNumber(arguments), 'the arguments object is not a number');
+ ok(!_.isNumber(undefined), 'undefined is not a number');
+ ok(_.isNumber(3 * 4 - 7 / 10), 'but numbers are');
+ ok(_.isNumber(NaN), 'NaN *is* a number');
+ ok(_.isNumber(Infinity), 'Infinity is a number');
+ ok(_.isNumber(iNumber), 'even from another frame');
+ ok(!_.isNumber('1'), 'numeric strings are not numbers');
+ });
+
+ test("isBoolean", function() {
+ ok(!_.isBoolean(2), 'a number is not a boolean');
+ ok(!_.isBoolean("string"), 'a string is not a boolean');
+ ok(!_.isBoolean("false"), 'the string "false" is not a boolean');
+ ok(!_.isBoolean("true"), 'the string "true" is not a boolean');
+ ok(!_.isBoolean(arguments), 'the arguments object is not a boolean');
+ ok(!_.isBoolean(undefined), 'undefined is not a boolean');
+ ok(!_.isBoolean(NaN), 'NaN is not a boolean');
+ ok(!_.isBoolean(null), 'null is not a boolean');
+ ok(_.isBoolean(true), 'but true is');
+ ok(_.isBoolean(false), 'and so is false');
+ ok(_.isBoolean(iBoolean), 'even from another frame');
+ });
+
+ test("isFunction", function() {
+ ok(!_.isFunction([1, 2, 3]), 'arrays are not functions');
+ ok(!_.isFunction('moe'), 'strings are not functions');
+ ok(_.isFunction(_.isFunction), 'but functions are');
+ ok(_.isFunction(iFunction), 'even from another frame');
+ });
+
+ test("isDate", function() {
+ ok(!_.isDate(100), 'numbers are not dates');
+ ok(!_.isDate({}), 'objects are not dates');
+ ok(_.isDate(new Date()), 'but dates are');
+ ok(_.isDate(iDate), 'even from another frame');
+ });
+
+ test("isRegExp", function() {
+ ok(!_.isRegExp(_.identity), 'functions are not RegExps');
+ ok(_.isRegExp(/identity/), 'but RegExps are');
+ ok(_.isRegExp(iRegExp), 'even from another frame');
+ });
+
+ test("isFinite", function() {
+ ok(!_.isFinite(undefined), 'undefined is not Finite');
+ ok(!_.isFinite(null), 'null is not Finite');
+ ok(!_.isFinite(NaN), 'NaN is not Finite');
+ ok(!_.isFinite(Infinity), 'Infinity is not Finite');
+ ok(!_.isFinite(-Infinity), '-Infinity is not Finite');
+ ok(!_.isFinite('12'), 'Strings are not numbers');
+ var obj = new Number(5);
+ ok(_.isFinite(obj), 'Number instances can be finite');
+ ok(_.isFinite(0), '0 is Finite');
+ ok(_.isFinite(123), 'Ints are Finite');
+ ok(_.isFinite(-12.44), 'Floats are Finite');
+ });
+
+ test("isNaN", function() {
+ ok(!_.isNaN(undefined), 'undefined is not NaN');
+ ok(!_.isNaN(null), 'null is not NaN');
+ ok(!_.isNaN(0), '0 is not NaN');
+ ok(_.isNaN(NaN), 'but NaN is');
+ ok(_.isNaN(iNaN), 'even from another frame');
+ ok(_.isNaN(new Number(NaN)), 'wrapped NaN is still NaN');
+ });
+
+ test("isNull", function() {
+ ok(!_.isNull(undefined), 'undefined is not null');
+ ok(!_.isNull(NaN), 'NaN is not null');
+ ok(_.isNull(null), 'but null is');
+ ok(_.isNull(iNull), 'even from another frame');
+ });
+
+ test("isUndefined", function() {
+ ok(!_.isUndefined(1), 'numbers are defined');
+ ok(!_.isUndefined(null), 'null is defined');
+ ok(!_.isUndefined(false), 'false is defined');
+ ok(!_.isUndefined(NaN), 'NaN is defined');
+ ok(_.isUndefined(), 'nothing is undefined');
+ ok(_.isUndefined(undefined), 'undefined is undefined');
+ ok(_.isUndefined(iUndefined), 'even from another frame');
+ });
+
+ if (window.ActiveXObject) {
+ test("IE host objects", function() {
+ var xml = new ActiveXObject("Msxml2.DOMDocument.3.0");
+ ok(!_.isNumber(xml));
+ ok(!_.isBoolean(xml));
+ ok(!_.isNaN(xml));
+ ok(!_.isFunction(xml));
+ ok(!_.isNull(xml));
+ ok(!_.isUndefined(xml));
+ });
+ }
+
+ test("tap", function() {
+ var intercepted = null;
+ var interceptor = function(obj) { intercepted = obj; };
+ var returned = _.tap(1, interceptor);
+ equal(intercepted, 1, "passes tapped object to interceptor");
+ equal(returned, 1, "returns tapped object");
+
+ returned = _([1,2,3]).chain().
+ map(function(n){ return n * 2; }).
+ max().
+ tap(interceptor).
+ value();
+ ok(returned == 6 && intercepted == 6, 'can use tapped objects in a chain');
+ });
+});
diff --git a/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/speed.js b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/speed.js
new file mode 100644
index 0000000..05e3f2a
--- /dev/null
+++ b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/speed.js
@@ -0,0 +1,75 @@
+(function() {
+
+ var numbers = [];
+ for (var i=0; i<1000; i++) numbers.push(i);
+ var objects = _.map(numbers, function(n){ return {num : n}; });
+ var randomized = _.sortBy(numbers, function(){ return Math.random(); });
+ var deep = _.map(_.range(100), function() { return _.range(1000); });
+
+ JSLitmus.test('_.each()', function() {
+ var timesTwo = [];
+ _.each(numbers, function(num){ timesTwo.push(num * 2); });
+ return timesTwo;
+ });
+
+ JSLitmus.test('_(list).each()', function() {
+ var timesTwo = [];
+ _(numbers).each(function(num){ timesTwo.push(num * 2); });
+ return timesTwo;
+ });
+
+ JSLitmus.test('jQuery.each()', function() {
+ var timesTwo = [];
+ jQuery.each(numbers, function(){ timesTwo.push(this * 2); });
+ return timesTwo;
+ });
+
+ JSLitmus.test('_.map()', function() {
+ return _.map(objects, function(obj){ return obj.num; });
+ });
+
+ JSLitmus.test('jQuery.map()', function() {
+ return jQuery.map(objects, function(obj){ return obj.num; });
+ });
+
+ JSLitmus.test('_.pluck()', function() {
+ return _.pluck(objects, 'num');
+ });
+
+ JSLitmus.test('_.uniq()', function() {
+ return _.uniq(randomized);
+ });
+
+ JSLitmus.test('_.uniq() (sorted)', function() {
+ return _.uniq(numbers, true);
+ });
+
+ JSLitmus.test('_.sortBy()', function() {
+ return _.sortBy(numbers, function(num){ return -num; });
+ });
+
+ JSLitmus.test('_.isEqual()', function() {
+ return _.isEqual(numbers, randomized);
+ });
+
+ JSLitmus.test('_.keys()', function() {
+ return _.keys(objects);
+ });
+
+ JSLitmus.test('_.values()', function() {
+ return _.values(objects);
+ });
+
+ JSLitmus.test('_.intersection()', function() {
+ return _.intersection(numbers, randomized);
+ });
+
+ JSLitmus.test('_.range()', function() {
+ return _.range(1000);
+ });
+
+ JSLitmus.test('_.flatten()', function() {
+ return _.flatten(deep);
+ });
+
+})();
diff --git a/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/utility.js b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/utility.js
new file mode 100644
index 0000000..c9be20a
--- /dev/null
+++ b/node_modules/grunt-legacy-log-utils/node_modules/underscore.string/test/test_underscore/utility.js
@@ -0,0 +1,249 @@
+$(document).ready(function() {
+
+ var templateSettings;
+
+ module("Utility", {
+
+ setup: function() {
+ templateSettings = _.clone(_.templateSettings);
+ },
+
+ teardown: function() {
+ _.templateSettings = templateSettings;
+ }
+
+ });
+
+ test("#750 - Return _ instance.", 2, function() {
+ var instance = _([]);
+ ok(_(instance) === instance);
+ ok(new _(instance) === instance);
+ });
+
+ test("identity", function() {
+ var moe = {name : 'moe'};
+ equal(_.identity(moe), moe, 'moe is the same as his identity');
+ });
+
+ test("uniqueId", function() {
+ var ids = [], i = 0;
+ while(i++ < 100) ids.push(_.uniqueId());
+ equal(_.uniq(ids).length, ids.length, 'can generate a globally-unique stream of ids');
+ });
+
+ test("times", function() {
+ var vals = [];
+ _.times(3, function (i) { vals.push(i); });
+ ok(_.isEqual(vals, [0,1,2]), "is 0 indexed");
+ //
+ vals = [];
+ _(3).times(function (i) { vals.push(i); });
+ ok(_.isEqual(vals, [0,1,2]), "works as a wrapper");
+ });
+
+ test("mixin", function() {
+ _.mixin({
+ myReverse: function(string) {
+ return string.split('').reverse().join('');
+ }
+ });
+ equal(_.myReverse('panacea'), 'aecanap', 'mixed in a function to _');
+ equal(_('champ').myReverse(), 'pmahc', 'mixed in a function to the OOP wrapper');
+ });
+
+ test("_.escape", function() {
+ equal(_.escape("Curly & Moe"), "Curly & Moe");
+ equal(_.escape("Curly & Moe"), "Curly & Moe");
+ equal(_.escape(null), '');
+ });
+
+ test("_.unescape", function() {
+ var string = "Curly & Moe";
+ equal(_.unescape("Curly & Moe"), string);
+ equal(_.unescape("Curly & Moe"), "Curly & Moe");
+ equal(_.unescape(null), '');
+ equal(_.unescape(_.escape(string)), string);
+ });
+
+ test("template", function() {
+ var basicTemplate = _.template("<%= thing %> is gettin' on my noives!");
+ var result = basicTemplate({thing : 'This'});
+ equal(result, "This is gettin' on my noives!", 'can do basic attribute interpolation');
+
+ var sansSemicolonTemplate = _.template("A <% this %> B");
+ equal(sansSemicolonTemplate(), "A B");
+
+ var backslashTemplate = _.template("<%= thing %> is \\ridanculous");
+ equal(backslashTemplate({thing: 'This'}), "This is \\ridanculous");
+
+ var escapeTemplate = _.template('<%= a ? "checked=\\"checked\\"" : "" %>');
+ equal(escapeTemplate({a: true}), 'checked="checked"', 'can handle slash escapes in interpolations.');
+
+ var fancyTemplate = _.template("<% \
+ for (key in people) { \
+ %>- <%= people[key] %>
<% } %>
");
+ result = fancyTemplate({people : {moe : "Moe", larry : "Larry", curly : "Curly"}});
+ equal(result, "", 'can run arbitrary javascript in templates');
+
+ var escapedCharsInJavascriptTemplate = _.template("<% _.each(numbers.split('\\n'), function(item) { %>- <%= item %>
<% }) %>
");
+ result = escapedCharsInJavascriptTemplate({numbers: "one\ntwo\nthree\nfour"});
+ equal(result, "", 'Can use escaped characters (e.g. \\n) in Javascript');
+
+ var namespaceCollisionTemplate = _.template("<%= pageCount %> <%= thumbnails[pageCount] %> <% _.each(thumbnails, function(p) { %>\">
<% }); %>");
+ result = namespaceCollisionTemplate({
+ pageCount: 3,
+ thumbnails: {
+ 1: "p1-thumbnail.gif",
+ 2: "p2-thumbnail.gif",
+ 3: "p3-thumbnail.gif"
+ }
+ });
+ equal(result, "3 p3-thumbnail.gif ");
+
+ var noInterpolateTemplate = _.template("Just some text. Hey, I know this is silly but it aids consistency.
Just some text. Hey, I know this is silly but it aids consistency.
' + func(text) + '
';
+ * });
+ *
+ * p('Fred, Wilma, & Pebbles');
+ * // => 'Fred, Wilma, & Pebbles
'
+ */
+ function wrap(value, wrapper) {
+ return createWrapper(wrapper, 16, [value]);
+ }
+
+ /*--------------------------------------------------------------------------*/
+
+ /**
+ * Creates a function that returns `value`.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {*} value The value to return from the new function.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * var getter = _.constant(object);
+ * getter() === object;
+ * // => true
+ */
+ function constant(value) {
+ return function() {
+ return value;
+ };
+ }
+
+ /**
+ * Produces a callback bound to an optional `thisArg`. If `func` is a property
+ * name the created callback will return the property value for a given element.
+ * If `func` is an object the created callback will return `true` for elements
+ * that contain the equivalent object properties, otherwise it will return `false`.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {*} [func=identity] The value to convert to a callback.
+ * @param {*} [thisArg] The `this` binding of the created callback.
+ * @param {number} [argCount] The number of arguments the callback accepts.
+ * @returns {Function} Returns a callback function.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'barney', 'age': 36 },
+ * { 'name': 'fred', 'age': 40 }
+ * ];
+ *
+ * // wrap to create custom callback shorthands
+ * _.createCallback = _.wrap(_.createCallback, function(func, callback, thisArg) {
+ * var match = /^(.+?)__([gl]t)(.+)$/.exec(callback);
+ * return !match ? func(callback, thisArg) : function(object) {
+ * return match[2] == 'gt' ? object[match[1]] > match[3] : object[match[1]] < match[3];
+ * };
+ * });
+ *
+ * _.filter(characters, 'age__gt38');
+ * // => [{ 'name': 'fred', 'age': 40 }]
+ */
+ function createCallback(func, thisArg, argCount) {
+ var type = typeof func;
+ if (func == null || type == 'function') {
+ return baseCreateCallback(func, thisArg, argCount);
+ }
+ // handle "_.pluck" style callback shorthands
+ if (type != 'object') {
+ return property(func);
+ }
+ var props = keys(func),
+ key = props[0],
+ a = func[key];
+
+ // handle "_.where" style callback shorthands
+ if (props.length == 1 && a === a && !isObject(a)) {
+ // fast path the common case of providing an object with a single
+ // property containing a primitive value
+ return function(object) {
+ var b = object[key];
+ return a === b && (a !== 0 || (1 / a == 1 / b));
+ };
+ }
+ return function(object) {
+ var length = props.length,
+ result = false;
+
+ while (length--) {
+ if (!(result = baseIsEqual(object[props[length]], func[props[length]], null, true))) {
+ break;
+ }
+ }
+ return result;
+ };
+ }
+
+ /**
+ * Converts the characters `&`, `<`, `>`, `"`, and `'` in `string` to their
+ * corresponding HTML entities.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} string The string to escape.
+ * @returns {string} Returns the escaped string.
+ * @example
+ *
+ * _.escape('Fred, Wilma, & Pebbles');
+ * // => 'Fred, Wilma, & Pebbles'
+ */
+ function escape(string) {
+ return string == null ? '' : String(string).replace(reUnescapedHtml, escapeHtmlChar);
+ }
+
+ /**
+ * This method returns the first argument provided to it.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {*} value Any value.
+ * @returns {*} Returns `value`.
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * _.identity(object) === object;
+ * // => true
+ */
+ function identity(value) {
+ return value;
+ }
+
+ /**
+ * Adds function properties of a source object to the destination object.
+ * If `object` is a function methods will be added to its prototype as well.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {Function|Object} [object=lodash] object The destination object.
+ * @param {Object} source The object of functions to add.
+ * @param {Object} [options] The options object.
+ * @param {boolean} [options.chain=true] Specify whether the functions added are chainable.
+ * @example
+ *
+ * function capitalize(string) {
+ * return string.charAt(0).toUpperCase() + string.slice(1).toLowerCase();
+ * }
+ *
+ * _.mixin({ 'capitalize': capitalize });
+ * _.capitalize('fred');
+ * // => 'Fred'
+ *
+ * _('fred').capitalize().value();
+ * // => 'Fred'
+ *
+ * _.mixin({ 'capitalize': capitalize }, { 'chain': false });
+ * _('fred').capitalize();
+ * // => 'Fred'
+ */
+ function mixin(object, source, options) {
+ var chain = true,
+ methodNames = source && functions(source);
+
+ if (!source || (!options && !methodNames.length)) {
+ if (options == null) {
+ options = source;
+ }
+ ctor = lodashWrapper;
+ source = object;
+ object = lodash;
+ methodNames = functions(source);
+ }
+ if (options === false) {
+ chain = false;
+ } else if (isObject(options) && 'chain' in options) {
+ chain = options.chain;
+ }
+ var ctor = object,
+ isFunc = isFunction(ctor);
+
+ forEach(methodNames, function(methodName) {
+ var func = object[methodName] = source[methodName];
+ if (isFunc) {
+ ctor.prototype[methodName] = function() {
+ var chainAll = this.__chain__,
+ value = this.__wrapped__,
+ args = [value];
+
+ push.apply(args, arguments);
+ var result = func.apply(object, args);
+ if (chain || chainAll) {
+ if (value === result && isObject(result)) {
+ return this;
+ }
+ result = new ctor(result);
+ result.__chain__ = chainAll;
+ }
+ return result;
+ };
+ }
+ });
+ }
+
+ /**
+ * Reverts the '_' variable to its previous value and returns a reference to
+ * the `lodash` function.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @returns {Function} Returns the `lodash` function.
+ * @example
+ *
+ * var lodash = _.noConflict();
+ */
+ function noConflict() {
+ context._ = oldDash;
+ return this;
+ }
+
+ /**
+ * A no-operation function.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @example
+ *
+ * var object = { 'name': 'fred' };
+ * _.noop(object) === undefined;
+ * // => true
+ */
+ function noop() {
+ // no operation performed
+ }
+
+ /**
+ * Gets the number of milliseconds that have elapsed since the Unix epoch
+ * (1 January 1970 00:00:00 UTC).
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @example
+ *
+ * var stamp = _.now();
+ * _.defer(function() { console.log(_.now() - stamp); });
+ * // => logs the number of milliseconds it took for the deferred function to be called
+ */
+ var now = isNative(now = Date.now) && now || function() {
+ return new Date().getTime();
+ };
+
+ /**
+ * Converts the given value into an integer of the specified radix.
+ * If `radix` is `undefined` or `0` a `radix` of `10` is used unless the
+ * `value` is a hexadecimal, in which case a `radix` of `16` is used.
+ *
+ * Note: This method avoids differences in native ES3 and ES5 `parseInt`
+ * implementations. See http://es5.github.io/#E.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} value The value to parse.
+ * @param {number} [radix] The radix used to interpret the value to parse.
+ * @returns {number} Returns the new integer value.
+ * @example
+ *
+ * _.parseInt('08');
+ * // => 8
+ */
+ var parseInt = nativeParseInt(whitespace + '08') == 8 ? nativeParseInt : function(value, radix) {
+ // Firefox < 21 and Opera < 15 follow the ES3 specified implementation of `parseInt`
+ return nativeParseInt(isString(value) ? value.replace(reLeadingSpacesAndZeros, '') : value, radix || 0);
+ };
+
+ /**
+ * Creates a "_.pluck" style function, which returns the `key` value of a
+ * given object.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} key The name of the property to retrieve.
+ * @returns {Function} Returns the new function.
+ * @example
+ *
+ * var characters = [
+ * { 'name': 'fred', 'age': 40 },
+ * { 'name': 'barney', 'age': 36 }
+ * ];
+ *
+ * var getName = _.property('name');
+ *
+ * _.map(characters, getName);
+ * // => ['barney', 'fred']
+ *
+ * _.sortBy(characters, getName);
+ * // => [{ 'name': 'barney', 'age': 36 }, { 'name': 'fred', 'age': 40 }]
+ */
+ function property(key) {
+ return function(object) {
+ return object[key];
+ };
+ }
+
+ /**
+ * Produces a random number between `min` and `max` (inclusive). If only one
+ * argument is provided a number between `0` and the given number will be
+ * returned. If `floating` is truey or either `min` or `max` are floats a
+ * floating-point number will be returned instead of an integer.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {number} [min=0] The minimum possible value.
+ * @param {number} [max=1] The maximum possible value.
+ * @param {boolean} [floating=false] Specify returning a floating-point number.
+ * @returns {number} Returns a random number.
+ * @example
+ *
+ * _.random(0, 5);
+ * // => an integer between 0 and 5
+ *
+ * _.random(5);
+ * // => also an integer between 0 and 5
+ *
+ * _.random(5, true);
+ * // => a floating-point number between 0 and 5
+ *
+ * _.random(1.2, 5.2);
+ * // => a floating-point number between 1.2 and 5.2
+ */
+ function random(min, max, floating) {
+ var noMin = min == null,
+ noMax = max == null;
+
+ if (floating == null) {
+ if (typeof min == 'boolean' && noMax) {
+ floating = min;
+ min = 1;
+ }
+ else if (!noMax && typeof max == 'boolean') {
+ floating = max;
+ noMax = true;
+ }
+ }
+ if (noMin && noMax) {
+ max = 1;
+ }
+ min = +min || 0;
+ if (noMax) {
+ max = min;
+ min = 0;
+ } else {
+ max = +max || 0;
+ }
+ if (floating || min % 1 || max % 1) {
+ var rand = nativeRandom();
+ return nativeMin(min + (rand * (max - min + parseFloat('1e-' + ((rand +'').length - 1)))), max);
+ }
+ return baseRandom(min, max);
+ }
+
+ /**
+ * Resolves the value of property `key` on `object`. If `key` is a function
+ * it will be invoked with the `this` binding of `object` and its result returned,
+ * else the property value is returned. If `object` is falsey then `undefined`
+ * is returned.
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {Object} object The object to inspect.
+ * @param {string} key The name of the property to resolve.
+ * @returns {*} Returns the resolved value.
+ * @example
+ *
+ * var object = {
+ * 'cheese': 'crumpets',
+ * 'stuff': function() {
+ * return 'nonsense';
+ * }
+ * };
+ *
+ * _.result(object, 'cheese');
+ * // => 'crumpets'
+ *
+ * _.result(object, 'stuff');
+ * // => 'nonsense'
+ */
+ function result(object, key) {
+ if (object) {
+ var value = object[key];
+ return isFunction(value) ? object[key]() : value;
+ }
+ }
+
+ /**
+ * A micro-templating method that handles arbitrary delimiters, preserves
+ * whitespace, and correctly escapes quotes within interpolated code.
+ *
+ * Note: In the development build, `_.template` utilizes sourceURLs for easier
+ * debugging. See http://www.html5rocks.com/en/tutorials/developertools/sourcemaps/#toc-sourceurl
+ *
+ * For more information on precompiling templates see:
+ * https://lodash.com/custom-builds
+ *
+ * For more information on Chrome extension sandboxes see:
+ * http://developer.chrome.com/stable/extensions/sandboxingEval.html
+ *
+ * @static
+ * @memberOf _
+ * @category Utilities
+ * @param {string} text The template text.
+ * @param {Object} data The data object used to populate the text.
+ * @param {Object} [options] The options object.
+ * @param {RegExp} [options.escape] The "escape" delimiter.
+ * @param {RegExp} [options.evaluate] The "evaluate" delimiter.
+ * @param {Object} [options.imports] An object to import into the template as local variables.
+ * @param {RegExp} [options.interpolate] The "interpolate" delimiter.
+ * @param {string} [sourceURL] The sourceURL of the template's compiled source.
+ * @param {string} [variable] The data object variable name.
+ * @returns {Function|string} Returns a compiled function when no `data` object
+ * is given, else it returns the interpolated text.
+ * @example
+ *
+ * // using the "interpolate" delimiter to create a compiled template
+ * var compiled = _.template('hello <%= name %>');
+ * compiled({ 'name': 'fred' });
+ * // => 'hello fred'
+ *
+ * // using the "escape" delimiter to escape HTML in data property values
+ * _.template('<%- value %>', { 'value': '').stripTags()
+=> 'a linkalert("hello world!")'
+```
+
+**toSentence** _.toSentence(array, [delimiter, lastDelimiter])
+
+Join an array into a human readable sentence.
+
+```javascript
+_.toSentence(['jQuery', 'Mootools', 'Prototype'])
+=> 'jQuery, Mootools and Prototype';
+
+_.toSentence(['jQuery', 'Mootools', 'Prototype'], ', ', ' unt ')
+=> 'jQuery, Mootools unt Prototype';
+```
+
+**toSentenceSerial** _.toSentenceSerial(array, [delimiter, lastDelimiter])
+
+The same as `toSentence`, but adjusts delimeters to use [Serial comma](http://en.wikipedia.org/wiki/Serial_comma).
+
+```javascript
+_.toSentenceSerial(['jQuery', 'Mootools'])
+=> 'jQuery and Mootools';
+
+_.toSentenceSerial(['jQuery', 'Mootools', 'Prototype'])
+=> 'jQuery, Mootools, and Prototype'
+
+_.toSentenceSerial(['jQuery', 'Mootools', 'Prototype'], ', ', ' unt ');
+=> 'jQuery, Mootools, unt Prototype';
+```
+
+**repeat** _.repeat(string, count, [separator])
+
+Repeats a string count times.
+
+```javascript
+_.repeat("foo", 3)
+=> 'foofoofoo';
+
+_.repeat("foo", 3, "bar")
+=> 'foobarfoobarfoo'
+```
+
+**surround** _.surround(string, wrap)
+
+Surround a string with another string.
+
+```javascript
+_.surround("foo", "ab")
+=> 'abfooab';
+```
+
+**quote** _.quote(string, quoteChar) or _.q(string, quoteChar)
+
+Quotes a string. `quoteChar` defaults to `"`.
+
+```javascript
+_.quote('foo', quoteChar)
+=> '"foo"';
+```
+**unquote** _.unquote(string, quoteChar)
+
+Unquotes a string. `quoteChar` defaults to `"`.
+
+```javascript
+_.unquote('"foo"')
+=> 'foo';
+_.unquote("'foo'", "'")
+=> 'foo';
+```
+
+
+**slugify** _.slugify(string)
+
+Transform text into a URL slug. Replaces whitespaces, accentuated, and special characters with a dash.
+
+```javascript
+_.slugify("Un éléphant à l'orée du bois")
+=> 'un-elephant-a-loree-du-bois';
+```
+
+***Caution: this function is charset dependent***
+
+**naturalCmp** array.sort(_.naturalCmp)
+
+Naturally sort strings like humans would do.
+
+```javascript
+['foo20', 'foo5'].sort(_.naturalCmp)
+=> [ 'foo5', 'foo20' ]
+```
+
+**toBoolean** _.toBoolean(string) or _.toBool(string)
+
+Turn strings that can be commonly considered as booleas to real booleans. Such as "true", "false", "1" and "0". This function is case insensitive.
+
+```javascript
+_.toBoolean("true")
+=> true
+_.toBoolean("FALSE")
+=> false
+_.toBoolean("random")
+=> undefined
+```
+
+It can be customized by giving arrays of truth and falsy value matcher as parameters. Matchers can be also RegExp objects.
+
+```javascript
+_.toBoolean("truthy", ["truthy"], ["falsy"])
+=> true
+_.toBoolean("true only at start", [/^true/])
+=> true
+```
+
+## Roadmap ##
+
+Any suggestions or bug reports are welcome. Just email me or more preferably open an issue.
+
+#### Problems
+
+We lose two things for `include` and `reverse` methods from `_.string`:
+
+* Calls like `_('foobar').include('bar')` aren't available;
+* Chaining isn't available too.
+
+But if you need this functionality you can create aliases for conflict functions which will be convenient for you:
+
+```javascript
+_.mixin({
+ includeString: _.str.include,
+ reverseString: _.str.reverse
+})
+
+// Now wrapper calls and chaining are available.
+_('foobar').chain().reverseString().includeString('rab').value()
+```
+
+#### Standalone Usage
+
+If you are using Underscore.string without Underscore. You also have `_.string` namespace for it and `_.str` alias
+But of course you can just reassign `_` variable with `_.string`
+
+```javascript
+_ = _.string
+```
+
+## Changelog ##
+
+### 2.3.3 ###
+
+* Add `toBoolean`
+* Add `unquote`
+* Add quote char option to `quote`
+* Support dash-separated words in `titleize`
+
+### 2.3.2 ###
+
+* Add `naturalCmp`
+* Bug fix to `camelize`
+* Add ă, ș, ț and ś to `slugify`
+* Doc updates
+* Add support for [component](http://component.io/)
+* [Full changelog](https://github.com/epeli/underscore.string/compare/v2.3.1...v2.3.2)
+
+### 2.3.1 ###
+
+* Bug fixes to `escapeHTML`, `classify`, `substr`
+* Faster `count`
+* Documentation fixes
+* [Full changelog](https://github.com/epeli/underscore.string/compare/v2.3.0...v2.3.1)
+
+### 2.3.0 ###
+
+* Added `numberformat` method
+* Added `levenshtein` method (Levenshtein distance calculation)
+* Added `swapCase` method
+* Changed default behavior of `words` method
+* Added `toSentenceSerial` method
+* Added `surround` and `quote` methods
+
+### 2.2.1 ###
+
+* Same as 2.2.0 (2.2.0rc on npm) to fix some npm drama
+
+### 2.2.0 ###
+
+* Capitalize method behavior changed
+* Various perfomance tweaks
+
+### 2.1.1###
+
+* Fixed words method bug
+* Added classify method
+
+### 2.1.0 ###
+
+* AMD support
+* Added toSentence method
+* Added slugify method
+* Lots of speed optimizations
+
+### 2.0.0 ###
+
+* Added prune, humanize functions
+* Added _.string (_.str) namespace for Underscore.string library
+* Removed includes function
+
+For upgrading to this version you need to mix in Underscore.string library to Underscore object:
+
+```javascript
+_.mixin(_.string.exports());
+```
+
+and all non-conflict Underscore.string functions will be available through Underscore object.
+Also function `includes` has been removed, you should replace this function by `_.str.include`
+or create alias `_.includes = _.str.include` and all your code will work fine.
+
+### 1.1.6 ###
+
+* Fixed reverse and truncate
+* Added isBlank, stripTags, inlude(alias for includes)
+* Added uglifier compression
+
+### 1.1.5 ###
+
+* Added strRight, strRightBack, strLeft, strLeftBack
+
+### 1.1.4 ###
+
+* Added pad, lpad, rpad, lrpad methods and aliases center, ljust, rjust
+* Integration with Underscore 1.1.6
+
+### 1.1.3 ###
+
+* Added methods: underscored, camelize, dasherize
+* Support newer version of npm
+
+### 1.1.2 ###
+
+* Created functions: lines, chars, words functions
+
+### 1.0.2 ###
+
+* Created integration test suite with underscore.js 1.1.4 (now it's absolutely compatible)
+* Removed 'reverse' function, because this function override underscore.js 'reverse'
+
+## Contribute ##
+
+* Fork & pull request. Don't forget about tests.
+* If you planning add some feature please create issue before.
+
+Otherwise changes will be rejected.
+
+## Contributors list ##
+[Can be found here](https://github.com/epeli/underscore.string/graphs/contributors).
+
+
+## Licence ##
+
+The MIT License
+
+Copyright (c) 2011 Esa-Matti Suuronen esa-matti@suuronen.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/node_modules/grunt-legacy-log/node_modules/underscore.string/Rakefile b/node_modules/grunt-legacy-log/node_modules/underscore.string/Rakefile
new file mode 100644
index 0000000..2cd9eed
--- /dev/null
+++ b/node_modules/grunt-legacy-log/node_modules/underscore.string/Rakefile
@@ -0,0 +1,23 @@
+# encoding: utf-8
+task default: :test
+
+desc 'Use UglifyJS to compress Underscore.string'
+task :build do
+ require 'uglifier'
+ source = File.read('lib/underscore.string.js', :encoding => 'utf-8')
+ compressed = Uglifier.compile(source, copyright: false)
+ File.open('dist/underscore.string.min.js', 'w'){ |f| f.write compressed }
+ compression_rate = compressed.length.to_f/source.length
+ puts "compressed dist/underscore.string.min.js: #{compressed.length}/#{source.length} #{(compression_rate * 100).round}%"
+end
+
+desc 'Run tests'
+task :test do
+ puts "Running underscore.string test suite."
+ result1 = system %{phantomjs ./test/run-qunit.js "test/test.html"}
+
+ puts "Running Underscore test suite."
+ result2 = system %{phantomjs ./test/run-qunit.js "test/test_underscore/index.html"}
+
+ exit(result1 && result2 ? 0 : 1)
+end
diff --git a/node_modules/grunt-legacy-log/node_modules/underscore.string/component.json b/node_modules/grunt-legacy-log/node_modules/underscore.string/component.json
new file mode 100644
index 0000000..ae91b65
--- /dev/null
+++ b/node_modules/grunt-legacy-log/node_modules/underscore.string/component.json
@@ -0,0 +1,11 @@
+{
+ "name": "underscore.string",
+ "repo": "epeli/underscore.string",
+ "description": "String manipulation extensions for Underscore.js javascript library",
+ "version": "2.3.3",
+ "keywords": ["underscore", "string"],
+ "dependencies": {},
+ "development": {},
+ "main": "lib/underscore.string.js",
+ "scripts": ["lib/underscore.string.js"]
+}
diff --git a/node_modules/grunt-legacy-log/node_modules/underscore.string/dist/underscore.string.min.js b/node_modules/grunt-legacy-log/node_modules/underscore.string/dist/underscore.string.min.js
new file mode 100644
index 0000000..4f6b2b9
--- /dev/null
+++ b/node_modules/grunt-legacy-log/node_modules/underscore.string/dist/underscore.string.min.js
@@ -0,0 +1 @@
+!function(e,n){"use strict";function r(e,n){var r,t,u=e.toLowerCase();for(n=[].concat(n),r=0;n.length>r;r+=1)if(t=n[r]){if(t.test&&t.test(e))return!0;if(t.toLowerCase()===u)return!0}}var t=n.prototype.trim,u=n.prototype.trimRight,i=n.prototype.trimLeft,l=function(e){return 1*e||0},o=function(e,n){if(1>n)return"";for(var r="";n>0;)1&n&&(r+=e),n>>=1,e+=e;return r},a=[].slice,c=function(e){return null==e?"\\s":e.source?e.source:"["+g.escapeRegExp(e)+"]"},s={lt:"<",gt:">",quot:'"',amp:"&",apos:"'"},f={};for(var p in s)f[s[p]]=p;f["'"]="#39";var h=function(){function e(e){return Object.prototype.toString.call(e).slice(8,-1).toLowerCase()}var r=o,t=function(){return t.cache.hasOwnProperty(arguments[0])||(t.cache[arguments[0]]=t.parse(arguments[0])),t.format.call(null,t.cache[arguments[0]],arguments)};return t.format=function(t,u){var i,l,o,a,c,s,f,p=1,g=t.length,d="",m=[];for(l=0;g>l;l++)if(d=e(t[l]),"string"===d)m.push(t[l]);else if("array"===d){if(a=t[l],a[2])for(i=u[p],o=0;a[2].length>o;o++){if(!i.hasOwnProperty(a[2][o]))throw new Error(h('[_.sprintf] property "%s" does not exist',a[2][o]));i=i[a[2][o]]}else i=a[1]?u[a[1]]:u[p++];if(/[^s]/.test(a[8])&&"number"!=e(i))throw new Error(h("[_.sprintf] expecting number but found %s",e(i)));switch(a[8]){case"b":i=i.toString(2);break;case"c":i=n.fromCharCode(i);break;case"d":i=parseInt(i,10);break;case"e":i=a[7]?i.toExponential(a[7]):i.toExponential();break;case"f":i=a[7]?parseFloat(i).toFixed(a[7]):parseFloat(i);break;case"o":i=i.toString(8);break;case"s":i=(i=n(i))&&a[7]?i.substring(0,a[7]):i;break;case"u":i=Math.abs(i);break;case"x":i=i.toString(16);break;case"X":i=i.toString(16).toUpperCase()}i=/[def]/.test(a[8])&&a[3]&&i>=0?"+"+i:i,s=a[4]?"0"==a[4]?"0":a[4].charAt(1):" ",f=a[6]-n(i).length,c=a[6]?r(s,f):"",m.push(a[5]?i+c:c+i)}return m.join("")},t.cache={},t.parse=function(e){for(var n=e,r=[],t=[],u=0;n;){if(null!==(r=/^[^\x25]+/.exec(n)))t.push(r[0]);else if(null!==(r=/^\x25{2}/.exec(n)))t.push("%");else{if(null===(r=/^\x25(?:([1-9]\d*)\$|\(([^\)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-fosuxX])/.exec(n)))throw new Error("[_.sprintf] huh?");if(r[2]){u|=1;var i=[],l=r[2],o=[];if(null===(o=/^([a-z_][a-z_\d]*)/i.exec(l)))throw new Error("[_.sprintf] huh?");for(i.push(o[1]);""!==(l=l.substring(o[0].length));)if(null!==(o=/^\.([a-z_][a-z_\d]*)/i.exec(l)))i.push(o[1]);else{if(null===(o=/^\[(\d+)\]/.exec(l)))throw new Error("[_.sprintf] huh?");i.push(o[1])}r[2]=i}else u|=2;if(3===u)throw new Error("[_.sprintf] mixing positional and named placeholders is not (yet) supported");t.push(r)}n=n.substring(r[0].length)}return t},t}(),g={VERSION:"2.3.0",isBlank:function(e){return null==e&&(e=""),/^\s*$/.test(e)},stripTags:function(e){return null==e?"":n(e).replace(/<\/?[^>]+>/g,"")},capitalize:function(e){return e=null==e?"":n(e),e.charAt(0).toUpperCase()+e.slice(1)},chop:function(e,r){return null==e?[]:(e=n(e),r=~~r,r>0?e.match(new RegExp(".{1,"+r+"}","g")):[e])},clean:function(e){return g.strip(e).replace(/\s+/g," ")},count:function(e,r){if(null==e||null==r)return 0;e=n(e),r=n(r);for(var t=0,u=0,i=r.length;;){if(u=e.indexOf(r,u),-1===u)break;t++,u+=i}return t},chars:function(e){return null==e?[]:n(e).split("")},swapCase:function(e){return null==e?"":n(e).replace(/\S/g,function(e){return e===e.toUpperCase()?e.toLowerCase():e.toUpperCase()})},escapeHTML:function(e){return null==e?"":n(e).replace(/[&<>"']/g,function(e){return"&"+f[e]+";"})},unescapeHTML:function(e){return null==e?"":n(e).replace(/\&([^;]+);/g,function(e,r){var t;return r in s?s[r]:(t=r.match(/^#x([\da-fA-F]+)$/))?n.fromCharCode(parseInt(t[1],16)):(t=r.match(/^#(\d+)$/))?n.fromCharCode(~~t[1]):e})},escapeRegExp:function(e){return null==e?"":n(e).replace(/([.*+?^=!:${}()|[\]\/\\])/g,"\\$1")},splice:function(e,n,r,t){var u=g.chars(e);return u.splice(~~n,~~r,t),u.join("")},insert:function(e,n,r){return g.splice(e,n,0,r)},include:function(e,r){return""===r?!0:null==e?!1:-1!==n(e).indexOf(r)},join:function(){var e=a.call(arguments),n=e.shift();return null==n&&(n=""),e.join(n)},lines:function(e){return null==e?[]:n(e).split("\n")},reverse:function(e){return g.chars(e).reverse().join("")},startsWith:function(e,r){return""===r?!0:null==e||null==r?!1:(e=n(e),r=n(r),e.length>=r.length&&e.slice(0,r.length)===r)},endsWith:function(e,r){return""===r?!0:null==e||null==r?!1:(e=n(e),r=n(r),e.length>=r.length&&e.slice(e.length-r.length)===r)},succ:function(e){return null==e?"":(e=n(e),e.slice(0,-1)+n.fromCharCode(e.charCodeAt(e.length-1)+1))},titleize:function(e){return null==e?"":(e=n(e).toLowerCase(),e.replace(/(?:^|\s|-)\S/g,function(e){return e.toUpperCase()}))},camelize:function(e){return g.trim(e).replace(/[-_\s]+(.)?/g,function(e,n){return n?n.toUpperCase():""})},underscored:function(e){return g.trim(e).replace(/([a-z\d])([A-Z]+)/g,"$1_$2").replace(/[-\s]+/g,"_").toLowerCase()},dasherize:function(e){return g.trim(e).replace(/([A-Z])/g,"-$1").replace(/[-_\s]+/g,"-").toLowerCase()},classify:function(e){return g.titleize(n(e).replace(/[\W_]/g," ")).replace(/\s/g,"")},humanize:function(e){return g.capitalize(g.underscored(e).replace(/_id$/,"").replace(/_/g," "))},trim:function(e,r){return null==e?"":!r&&t?t.call(e):(r=c(r),n(e).replace(new RegExp("^"+r+"+|"+r+"+$","g"),""))},ltrim:function(e,r){return null==e?"":!r&&i?i.call(e):(r=c(r),n(e).replace(new RegExp("^"+r+"+"),""))},rtrim:function(e,r){return null==e?"":!r&&u?u.call(e):(r=c(r),n(e).replace(new RegExp(r+"+$"),""))},truncate:function(e,r,t){return null==e?"":(e=n(e),t=t||"...",r=~~r,e.length>r?e.slice(0,r)+t:e)},prune:function(e,r,t){if(null==e)return"";if(e=n(e),r=~~r,t=null!=t?n(t):"...",r>=e.length)return e;var u=function(e){return e.toUpperCase()!==e.toLowerCase()?"A":" "},i=e.slice(0,r+1).replace(/.(?=\W*\w*$)/g,u);return i=i.slice(i.length-2).match(/\w\w/)?i.replace(/\s*\S+$/,""):g.rtrim(i.slice(0,i.length-1)),(i+t).length>e.length?e:e.slice(0,i.length)+t},words:function(e,n){return g.isBlank(e)?[]:g.trim(e,n).split(n||/\s+/)},pad:function(e,r,t,u){e=null==e?"":n(e),r=~~r;var i=0;switch(t?t.length>1&&(t=t.charAt(0)):t=" ",u){case"right":return i=r-e.length,e+o(t,i);case"both":return i=r-e.length,o(t,Math.ceil(i/2))+e+o(t,Math.floor(i/2));default:return i=r-e.length,o(t,i)+e}},lpad:function(e,n,r){return g.pad(e,n,r)},rpad:function(e,n,r){return g.pad(e,n,r,"right")},lrpad:function(e,n,r){return g.pad(e,n,r,"both")},sprintf:h,vsprintf:function(e,n){return n.unshift(e),h.apply(null,n)},toNumber:function(e,n){return e?(e=g.trim(e),e.match(/^-?\d+(?:\.\d+)?$/)?l(l(e).toFixed(~~n)):0/0):0},numberFormat:function(e,n,r,t){if(isNaN(e)||null==e)return"";e=e.toFixed(~~n),t="string"==typeof t?t:",";var u=e.split("."),i=u[0],l=u[1]?(r||".")+u[1]:"";return i.replace(/(\d)(?=(?:\d{3})+$)/g,"$1"+t)+l},strRight:function(e,r){if(null==e)return"";e=n(e),r=null!=r?n(r):r;var t=r?e.indexOf(r):-1;return~t?e.slice(t+r.length,e.length):e},strRightBack:function(e,r){if(null==e)return"";e=n(e),r=null!=r?n(r):r;var t=r?e.lastIndexOf(r):-1;return~t?e.slice(t+r.length,e.length):e},strLeft:function(e,r){if(null==e)return"";e=n(e),r=null!=r?n(r):r;var t=r?e.indexOf(r):-1;return~t?e.slice(0,t):e},strLeftBack:function(e,n){if(null==e)return"";e+="",n=null!=n?""+n:n;var r=e.lastIndexOf(n);return~r?e.slice(0,r):e},toSentence:function(e,n,r,t){n=n||", ",r=r||" and ";var u=e.slice(),i=u.pop();return e.length>2&&t&&(r=g.rtrim(n)+r),u.length?u.join(n)+r+i:i},toSentenceSerial:function(){var e=a.call(arguments);return e[3]=!0,g.toSentence.apply(g,e)},slugify:function(e){if(null==e)return"";var r="ąàáäâãåæăćęèéëêìíïîłńòóöôõøśșțùúüûñçżź",t="aaaaaaaaaceeeeeiiiilnoooooosstuuuunczz",u=new RegExp(c(r),"g");return e=n(e).toLowerCase().replace(u,function(e){var n=r.indexOf(e);return t.charAt(n)||"-"}),g.dasherize(e.replace(/[^\w\s-]/g,""))},surround:function(e,n){return[n,e,n].join("")},quote:function(e,n){return g.surround(e,n||'"')},unquote:function(e,n){return n=n||'"',e[0]===n&&e[e.length-1]===n?e.slice(1,e.length-1):e},exports:function(){var e={};for(var n in this)this.hasOwnProperty(n)&&!n.match(/^(?:include|contains|reverse)$/)&&(e[n]=this[n]);return e},repeat:function(e,r,t){if(null==e)return"";if(r=~~r,null==t)return o(n(e),r);for(var u=[];r>0;u[--r]=e);return u.join(t)},naturalCmp:function(e,r){if(e==r)return 0;if(!e)return-1;if(!r)return 1;for(var t=/(\.\d+)|(\d+)|(\D+)/g,u=n(e).toLowerCase().match(t),i=n(r).toLowerCase().match(t),l=Math.min(u.length,i.length),o=0;l>o;o++){var a=u[o],c=i[o];if(a!==c){var s=parseInt(a,10);if(!isNaN(s)){var f=parseInt(c,10);if(!isNaN(f)&&s-f)return s-f}return c>a?-1:1}}return u.length===i.length?u.length-i.length:r>e?-1:1},levenshtein:function(e,r){if(null==e&&null==r)return 0;if(null==e)return n(r).length;if(null==r)return n(e).length;e=n(e),r=n(r);for(var t,u,i=[],l=0;r.length>=l;l++)for(var o=0;e.length>=o;o++)u=l&&o?e.charAt(o-1)===r.charAt(l-1)?t:Math.min(i[o],i[o-1],t)+1:l+o,t=i[o],i[o]=u;return i.pop()},toBoolean:function(e,n,t){return"number"==typeof e&&(e=""+e),"string"!=typeof e?!!e:(e=g.trim(e),r(e,n||["true","1"])?!0:r(e,t||["false","0"])?!1:void 0)}};g.strip=g.trim,g.lstrip=g.ltrim,g.rstrip=g.rtrim,g.center=g.lrpad,g.rjust=g.lpad,g.ljust=g.rpad,g.contains=g.include,g.q=g.quote,g.toBool=g.toBoolean,"undefined"!=typeof exports&&("undefined"!=typeof module&&module.exports&&(module.exports=g),exports._s=g),"function"==typeof define&&define.amd&&define("underscore.string",[],function(){return g}),e._=e._||{},e._.string=e._.str=g}(this,String);
\ No newline at end of file
diff --git a/node_modules/grunt-legacy-log/node_modules/underscore.string/lib/underscore.string.js b/node_modules/grunt-legacy-log/node_modules/underscore.string/lib/underscore.string.js
new file mode 100644
index 0000000..8761117
--- /dev/null
+++ b/node_modules/grunt-legacy-log/node_modules/underscore.string/lib/underscore.string.js
@@ -0,0 +1,673 @@
+// Underscore.string
+// (c) 2010 Esa-Matti Suuronen
+// Underscore.string is freely distributable under the terms of the MIT license.
+// Documentation: https://github.com/epeli/underscore.string
+// Some code is borrowed from MooTools and Alexandru Marasteanu.
+// Version '2.3.2'
+
+!function(root, String){
+ 'use strict';
+
+ // Defining helper functions.
+
+ var nativeTrim = String.prototype.trim;
+ var nativeTrimRight = String.prototype.trimRight;
+ var nativeTrimLeft = String.prototype.trimLeft;
+
+ var parseNumber = function(source) { return source * 1 || 0; };
+
+ var strRepeat = function(str, qty){
+ if (qty < 1) return '';
+ var result = '';
+ while (qty > 0) {
+ if (qty & 1) result += str;
+ qty >>= 1, str += str;
+ }
+ return result;
+ };
+
+ var slice = [].slice;
+
+ var defaultToWhiteSpace = function(characters) {
+ if (characters == null)
+ return '\\s';
+ else if (characters.source)
+ return characters.source;
+ else
+ return '[' + _s.escapeRegExp(characters) + ']';
+ };
+
+ // Helper for toBoolean
+ function boolMatch(s, matchers) {
+ var i, matcher, down = s.toLowerCase();
+ matchers = [].concat(matchers);
+ for (i = 0; i < matchers.length; i += 1) {
+ matcher = matchers[i];
+ if (!matcher) continue;
+ if (matcher.test && matcher.test(s)) return true;
+ if (matcher.toLowerCase() === down) return true;
+ }
+ }
+
+ var escapeChars = {
+ lt: '<',
+ gt: '>',
+ quot: '"',
+ amp: '&',
+ apos: "'"
+ };
+
+ var reversedEscapeChars = {};
+ for(var key in escapeChars) reversedEscapeChars[escapeChars[key]] = key;
+ reversedEscapeChars["'"] = '#39';
+
+ // sprintf() for JavaScript 0.7-beta1
+ // http://www.diveintojavascript.com/projects/javascript-sprintf
+ //
+ // Copyright (c) Alexandru Marasteanu
+ // All rights reserved.
+
+ var sprintf = (function() {
+ function get_type(variable) {
+ return Object.prototype.toString.call(variable).slice(8, -1).toLowerCase();
+ }
+
+ var str_repeat = strRepeat;
+
+ var str_format = function() {
+ if (!str_format.cache.hasOwnProperty(arguments[0])) {
+ str_format.cache[arguments[0]] = str_format.parse(arguments[0]);
+ }
+ return str_format.format.call(null, str_format.cache[arguments[0]], arguments);
+ };
+
+ str_format.format = function(parse_tree, argv) {
+ var cursor = 1, tree_length = parse_tree.length, node_type = '', arg, output = [], i, k, match, pad, pad_character, pad_length;
+ for (i = 0; i < tree_length; i++) {
+ node_type = get_type(parse_tree[i]);
+ if (node_type === 'string') {
+ output.push(parse_tree[i]);
+ }
+ else if (node_type === 'array') {
+ match = parse_tree[i]; // convenience purposes only
+ if (match[2]) { // keyword argument
+ arg = argv[cursor];
+ for (k = 0; k < match[2].length; k++) {
+ if (!arg.hasOwnProperty(match[2][k])) {
+ throw new Error(sprintf('[_.sprintf] property "%s" does not exist', match[2][k]));
+ }
+ arg = arg[match[2][k]];
+ }
+ } else if (match[1]) { // positional argument (explicit)
+ arg = argv[match[1]];
+ }
+ else { // positional argument (implicit)
+ arg = argv[cursor++];
+ }
+
+ if (/[^s]/.test(match[8]) && (get_type(arg) != 'number')) {
+ throw new Error(sprintf('[_.sprintf] expecting number but found %s', get_type(arg)));
+ }
+ switch (match[8]) {
+ case 'b': arg = arg.toString(2); break;
+ case 'c': arg = String.fromCharCode(arg); break;
+ case 'd': arg = parseInt(arg, 10); break;
+ case 'e': arg = match[7] ? arg.toExponential(match[7]) : arg.toExponential(); break;
+ case 'f': arg = match[7] ? parseFloat(arg).toFixed(match[7]) : parseFloat(arg); break;
+ case 'o': arg = arg.toString(8); break;
+ case 's': arg = ((arg = String(arg)) && match[7] ? arg.substring(0, match[7]) : arg); break;
+ case 'u': arg = Math.abs(arg); break;
+ case 'x': arg = arg.toString(16); break;
+ case 'X': arg = arg.toString(16).toUpperCase(); break;
+ }
+ arg = (/[def]/.test(match[8]) && match[3] && arg >= 0 ? '+'+ arg : arg);
+ pad_character = match[4] ? match[4] == '0' ? '0' : match[4].charAt(1) : ' ';
+ pad_length = match[6] - String(arg).length;
+ pad = match[6] ? str_repeat(pad_character, pad_length) : '';
+ output.push(match[5] ? arg + pad : pad + arg);
+ }
+ }
+ return output.join('');
+ };
+
+ str_format.cache = {};
+
+ str_format.parse = function(fmt) {
+ var _fmt = fmt, match = [], parse_tree = [], arg_names = 0;
+ while (_fmt) {
+ if ((match = /^[^\x25]+/.exec(_fmt)) !== null) {
+ parse_tree.push(match[0]);
+ }
+ else if ((match = /^\x25{2}/.exec(_fmt)) !== null) {
+ parse_tree.push('%');
+ }
+ else if ((match = /^\x25(?:([1-9]\d*)\$|\(([^\)]+)\))?(\+)?(0|'[^$])?(-)?(\d+)?(?:\.(\d+))?([b-fosuxX])/.exec(_fmt)) !== null) {
+ if (match[2]) {
+ arg_names |= 1;
+ var field_list = [], replacement_field = match[2], field_match = [];
+ if ((field_match = /^([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) {
+ field_list.push(field_match[1]);
+ while ((replacement_field = replacement_field.substring(field_match[0].length)) !== '') {
+ if ((field_match = /^\.([a-z_][a-z_\d]*)/i.exec(replacement_field)) !== null) {
+ field_list.push(field_match[1]);
+ }
+ else if ((field_match = /^\[(\d+)\]/.exec(replacement_field)) !== null) {
+ field_list.push(field_match[1]);
+ }
+ else {
+ throw new Error('[_.sprintf] huh?');
+ }
+ }
+ }
+ else {
+ throw new Error('[_.sprintf] huh?');
+ }
+ match[2] = field_list;
+ }
+ else {
+ arg_names |= 2;
+ }
+ if (arg_names === 3) {
+ throw new Error('[_.sprintf] mixing positional and named placeholders is not (yet) supported');
+ }
+ parse_tree.push(match);
+ }
+ else {
+ throw new Error('[_.sprintf] huh?');
+ }
+ _fmt = _fmt.substring(match[0].length);
+ }
+ return parse_tree;
+ };
+
+ return str_format;
+ })();
+
+
+
+ // Defining underscore.string
+
+ var _s = {
+
+ VERSION: '2.3.0',
+
+ isBlank: function(str){
+ if (str == null) str = '';
+ return (/^\s*$/).test(str);
+ },
+
+ stripTags: function(str){
+ if (str == null) return '';
+ return String(str).replace(/<\/?[^>]+>/g, '');
+ },
+
+ capitalize : function(str){
+ str = str == null ? '' : String(str);
+ return str.charAt(0).toUpperCase() + str.slice(1);
+ },
+
+ chop: function(str, step){
+ if (str == null) return [];
+ str = String(str);
+ step = ~~step;
+ return step > 0 ? str.match(new RegExp('.{1,' + step + '}', 'g')) : [str];
+ },
+
+ clean: function(str){
+ return _s.strip(str).replace(/\s+/g, ' ');
+ },
+
+ count: function(str, substr){
+ if (str == null || substr == null) return 0;
+
+ str = String(str);
+ substr = String(substr);
+
+ var count = 0,
+ pos = 0,
+ length = substr.length;
+
+ while (true) {
+ pos = str.indexOf(substr, pos);
+ if (pos === -1) break;
+ count++;
+ pos += length;
+ }
+
+ return count;
+ },
+
+ chars: function(str) {
+ if (str == null) return [];
+ return String(str).split('');
+ },
+
+ swapCase: function(str) {
+ if (str == null) return '';
+ return String(str).replace(/\S/g, function(c){
+ return c === c.toUpperCase() ? c.toLowerCase() : c.toUpperCase();
+ });
+ },
+
+ escapeHTML: function(str) {
+ if (str == null) return '';
+ return String(str).replace(/[&<>"']/g, function(m){ return '&' + reversedEscapeChars[m] + ';'; });
+ },
+
+ unescapeHTML: function(str) {
+ if (str == null) return '';
+ return String(str).replace(/\&([^;]+);/g, function(entity, entityCode){
+ var match;
+
+ if (entityCode in escapeChars) {
+ return escapeChars[entityCode];
+ } else if (match = entityCode.match(/^#x([\da-fA-F]+)$/)) {
+ return String.fromCharCode(parseInt(match[1], 16));
+ } else if (match = entityCode.match(/^#(\d+)$/)) {
+ return String.fromCharCode(~~match[1]);
+ } else {
+ return entity;
+ }
+ });
+ },
+
+ escapeRegExp: function(str){
+ if (str == null) return '';
+ return String(str).replace(/([.*+?^=!:${}()|[\]\/\\])/g, '\\$1');
+ },
+
+ splice: function(str, i, howmany, substr){
+ var arr = _s.chars(str);
+ arr.splice(~~i, ~~howmany, substr);
+ return arr.join('');
+ },
+
+ insert: function(str, i, substr){
+ return _s.splice(str, i, 0, substr);
+ },
+
+ include: function(str, needle){
+ if (needle === '') return true;
+ if (str == null) return false;
+ return String(str).indexOf(needle) !== -1;
+ },
+
+ join: function() {
+ var args = slice.call(arguments),
+ separator = args.shift();
+
+ if (separator == null) separator = '';
+
+ return args.join(separator);
+ },
+
+ lines: function(str) {
+ if (str == null) return [];
+ return String(str).split("\n");
+ },
+
+ reverse: function(str){
+ return _s.chars(str).reverse().join('');
+ },
+
+ startsWith: function(str, starts){
+ if (starts === '') return true;
+ if (str == null || starts == null) return false;
+ str = String(str); starts = String(starts);
+ return str.length >= starts.length && str.slice(0, starts.length) === starts;
+ },
+
+ endsWith: function(str, ends){
+ if (ends === '') return true;
+ if (str == null || ends == null) return false;
+ str = String(str); ends = String(ends);
+ return str.length >= ends.length && str.slice(str.length - ends.length) === ends;
+ },
+
+ succ: function(str){
+ if (str == null) return '';
+ str = String(str);
+ return str.slice(0, -1) + String.fromCharCode(str.charCodeAt(str.length-1) + 1);
+ },
+
+ titleize: function(str){
+ if (str == null) return '';
+ str = String(str).toLowerCase();
+ return str.replace(/(?:^|\s|-)\S/g, function(c){ return c.toUpperCase(); });
+ },
+
+ camelize: function(str){
+ return _s.trim(str).replace(/[-_\s]+(.)?/g, function(match, c){ return c ? c.toUpperCase() : ""; });
+ },
+
+ underscored: function(str){
+ return _s.trim(str).replace(/([a-z\d])([A-Z]+)/g, '$1_$2').replace(/[-\s]+/g, '_').toLowerCase();
+ },
+
+ dasherize: function(str){
+ return _s.trim(str).replace(/([A-Z])/g, '-$1').replace(/[-_\s]+/g, '-').toLowerCase();
+ },
+
+ classify: function(str){
+ return _s.titleize(String(str).replace(/[\W_]/g, ' ')).replace(/\s/g, '');
+ },
+
+ humanize: function(str){
+ return _s.capitalize(_s.underscored(str).replace(/_id$/,'').replace(/_/g, ' '));
+ },
+
+ trim: function(str, characters){
+ if (str == null) return '';
+ if (!characters && nativeTrim) return nativeTrim.call(str);
+ characters = defaultToWhiteSpace(characters);
+ return String(str).replace(new RegExp('\^' + characters + '+|' + characters + '+$', 'g'), '');
+ },
+
+ ltrim: function(str, characters){
+ if (str == null) return '';
+ if (!characters && nativeTrimLeft) return nativeTrimLeft.call(str);
+ characters = defaultToWhiteSpace(characters);
+ return String(str).replace(new RegExp('^' + characters + '+'), '');
+ },
+
+ rtrim: function(str, characters){
+ if (str == null) return '';
+ if (!characters && nativeTrimRight) return nativeTrimRight.call(str);
+ characters = defaultToWhiteSpace(characters);
+ return String(str).replace(new RegExp(characters + '+$'), '');
+ },
+
+ truncate: function(str, length, truncateStr){
+ if (str == null) return '';
+ str = String(str); truncateStr = truncateStr || '...';
+ length = ~~length;
+ return str.length > length ? str.slice(0, length) + truncateStr : str;
+ },
+
+ /**
+ * _s.prune: a more elegant version of truncate
+ * prune extra chars, never leaving a half-chopped word.
+ * @author github.com/rwz
+ */
+ prune: function(str, length, pruneStr){
+ if (str == null) return '';
+
+ str = String(str); length = ~~length;
+ pruneStr = pruneStr != null ? String(pruneStr) : '...';
+
+ if (str.length <= length) return str;
+
+ var tmpl = function(c){ return c.toUpperCase() !== c.toLowerCase() ? 'A' : ' '; },
+ template = str.slice(0, length+1).replace(/.(?=\W*\w*$)/g, tmpl); // 'Hello, world' -> 'HellAA AAAAA'
+
+ if (template.slice(template.length-2).match(/\w\w/))
+ template = template.replace(/\s*\S+$/, '');
+ else
+ template = _s.rtrim(template.slice(0, template.length-1));
+
+ return (template+pruneStr).length > str.length ? str : str.slice(0, template.length)+pruneStr;
+ },
+
+ words: function(str, delimiter) {
+ if (_s.isBlank(str)) return [];
+ return _s.trim(str, delimiter).split(delimiter || /\s+/);
+ },
+
+ pad: function(str, length, padStr, type) {
+ str = str == null ? '' : String(str);
+ length = ~~length;
+
+ var padlen = 0;
+
+ if (!padStr)
+ padStr = ' ';
+ else if (padStr.length > 1)
+ padStr = padStr.charAt(0);
+
+ switch(type) {
+ case 'right':
+ padlen = length - str.length;
+ return str + strRepeat(padStr, padlen);
+ case 'both':
+ padlen = length - str.length;
+ return strRepeat(padStr, Math.ceil(padlen/2)) + str
+ + strRepeat(padStr, Math.floor(padlen/2));
+ default: // 'left'
+ padlen = length - str.length;
+ return strRepeat(padStr, padlen) + str;
+ }
+ },
+
+ lpad: function(str, length, padStr) {
+ return _s.pad(str, length, padStr);
+ },
+
+ rpad: function(str, length, padStr) {
+ return _s.pad(str, length, padStr, 'right');
+ },
+
+ lrpad: function(str, length, padStr) {
+ return _s.pad(str, length, padStr, 'both');
+ },
+
+ sprintf: sprintf,
+
+ vsprintf: function(fmt, argv){
+ argv.unshift(fmt);
+ return sprintf.apply(null, argv);
+ },
+
+ toNumber: function(str, decimals) {
+ if (!str) return 0;
+ str = _s.trim(str);
+ if (!str.match(/^-?\d+(?:\.\d+)?$/)) return NaN;
+ return parseNumber(parseNumber(str).toFixed(~~decimals));
+ },
+
+ numberFormat : function(number, dec, dsep, tsep) {
+ if (isNaN(number) || number == null) return '';
+
+ number = number.toFixed(~~dec);
+ tsep = typeof tsep == 'string' ? tsep : ',';
+
+ var parts = number.split('.'), fnums = parts[0],
+ decimals = parts[1] ? (dsep || '.') + parts[1] : '';
+
+ return fnums.replace(/(\d)(?=(?:\d{3})+$)/g, '$1' + tsep) + decimals;
+ },
+
+ strRight: function(str, sep){
+ if (str == null) return '';
+ str = String(str); sep = sep != null ? String(sep) : sep;
+ var pos = !sep ? -1 : str.indexOf(sep);
+ return ~pos ? str.slice(pos+sep.length, str.length) : str;
+ },
+
+ strRightBack: function(str, sep){
+ if (str == null) return '';
+ str = String(str); sep = sep != null ? String(sep) : sep;
+ var pos = !sep ? -1 : str.lastIndexOf(sep);
+ return ~pos ? str.slice(pos+sep.length, str.length) : str;
+ },
+
+ strLeft: function(str, sep){
+ if (str == null) return '';
+ str = String(str); sep = sep != null ? String(sep) : sep;
+ var pos = !sep ? -1 : str.indexOf(sep);
+ return ~pos ? str.slice(0, pos) : str;
+ },
+
+ strLeftBack: function(str, sep){
+ if (str == null) return '';
+ str += ''; sep = sep != null ? ''+sep : sep;
+ var pos = str.lastIndexOf(sep);
+ return ~pos ? str.slice(0, pos) : str;
+ },
+
+ toSentence: function(array, separator, lastSeparator, serial) {
+ separator = separator || ', ';
+ lastSeparator = lastSeparator || ' and ';
+ var a = array.slice(), lastMember = a.pop();
+
+ if (array.length > 2 && serial) lastSeparator = _s.rtrim(separator) + lastSeparator;
+
+ return a.length ? a.join(separator) + lastSeparator + lastMember : lastMember;
+ },
+
+ toSentenceSerial: function() {
+ var args = slice.call(arguments);
+ args[3] = true;
+ return _s.toSentence.apply(_s, args);
+ },
+
+ slugify: function(str) {
+ if (str == null) return '';
+
+ var from = "ąàáäâãåæăćęèéëêìíïîłńòóöôõøśșțùúüûñçżź",
+ to = "aaaaaaaaaceeeeeiiiilnoooooosstuuuunczz",
+ regex = new RegExp(defaultToWhiteSpace(from), 'g');
+
+ str = String(str).toLowerCase().replace(regex, function(c){
+ var index = from.indexOf(c);
+ return to.charAt(index) || '-';
+ });
+
+ return _s.dasherize(str.replace(/[^\w\s-]/g, ''));
+ },
+
+ surround: function(str, wrapper) {
+ return [wrapper, str, wrapper].join('');
+ },
+
+ quote: function(str, quoteChar) {
+ return _s.surround(str, quoteChar || '"');
+ },
+
+ unquote: function(str, quoteChar) {
+ quoteChar = quoteChar || '"';
+ if (str[0] === quoteChar && str[str.length-1] === quoteChar)
+ return str.slice(1,str.length-1);
+ else return str;
+ },
+
+ exports: function() {
+ var result = {};
+
+ for (var prop in this) {
+ if (!this.hasOwnProperty(prop) || prop.match(/^(?:include|contains|reverse)$/)) continue;
+ result[prop] = this[prop];
+ }
+
+ return result;
+ },
+
+ repeat: function(str, qty, separator){
+ if (str == null) return '';
+
+ qty = ~~qty;
+
+ // using faster implementation if separator is not needed;
+ if (separator == null) return strRepeat(String(str), qty);
+
+ // this one is about 300x slower in Google Chrome
+ for (var repeat = []; qty > 0; repeat[--qty] = str) {}
+ return repeat.join(separator);
+ },
+
+ naturalCmp: function(str1, str2){
+ if (str1 == str2) return 0;
+ if (!str1) return -1;
+ if (!str2) return 1;
+
+ var cmpRegex = /(\.\d+)|(\d+)|(\D+)/g,
+ tokens1 = String(str1).toLowerCase().match(cmpRegex),
+ tokens2 = String(str2).toLowerCase().match(cmpRegex),
+ count = Math.min(tokens1.length, tokens2.length);
+
+ for(var i = 0; i < count; i++) {
+ var a = tokens1[i], b = tokens2[i];
+
+ if (a !== b){
+ var num1 = parseInt(a, 10);
+ if (!isNaN(num1)){
+ var num2 = parseInt(b, 10);
+ if (!isNaN(num2) && num1 - num2)
+ return num1 - num2;
+ }
+ return a < b ? -1 : 1;
+ }
+ }
+
+ if (tokens1.length === tokens2.length)
+ return tokens1.length - tokens2.length;
+
+ return str1 < str2 ? -1 : 1;
+ },
+
+ levenshtein: function(str1, str2) {
+ if (str1 == null && str2 == null) return 0;
+ if (str1 == null) return String(str2).length;
+ if (str2 == null) return String(str1).length;
+
+ str1 = String(str1); str2 = String(str2);
+
+ var current = [], prev, value;
+
+ for (var i = 0; i <= str2.length; i++)
+ for (var j = 0; j <= str1.length; j++) {
+ if (i && j)
+ if (str1.charAt(j - 1) === str2.charAt(i - 1))
+ value = prev;
+ else
+ value = Math.min(current[j], current[j - 1], prev) + 1;
+ else
+ value = i + j;
+
+ prev = current[j];
+ current[j] = value;
+ }
+
+ return current.pop();
+ },
+
+ toBoolean: function(str, trueValues, falseValues) {
+ if (typeof str === "number") str = "" + str;
+ if (typeof str !== "string") return !!str;
+ str = _s.trim(str);
+ if (boolMatch(str, trueValues || ["true", "1"])) return true;
+ if (boolMatch(str, falseValues || ["false", "0"])) return false;
+ }
+ };
+
+ // Aliases
+
+ _s.strip = _s.trim;
+ _s.lstrip = _s.ltrim;
+ _s.rstrip = _s.rtrim;
+ _s.center = _s.lrpad;
+ _s.rjust = _s.lpad;
+ _s.ljust = _s.rpad;
+ _s.contains = _s.include;
+ _s.q = _s.quote;
+ _s.toBool = _s.toBoolean;
+
+ // Exporting
+
+ // CommonJS module is defined
+ if (typeof exports !== 'undefined') {
+ if (typeof module !== 'undefined' && module.exports)
+ module.exports = _s;
+
+ exports._s = _s;
+ }
+
+ // Register as a named module with AMD.
+ if (typeof define === 'function' && define.amd)
+ define('underscore.string', [], function(){ return _s; });
+
+
+ // Integrate with Underscore.js if defined
+ // or create our own underscore object.
+ root._ = root._ || {};
+ root._.string = root._.str = _s;
+}(this, String);
diff --git a/node_modules/grunt-legacy-log/node_modules/underscore.string/libpeerconnection.log b/node_modules/grunt-legacy-log/node_modules/underscore.string/libpeerconnection.log
new file mode 100644
index 0000000..e69de29
diff --git a/node_modules/grunt-legacy-log/node_modules/underscore.string/package.json b/node_modules/grunt-legacy-log/node_modules/underscore.string/package.json
new file mode 100644
index 0000000..c2e03c9
--- /dev/null
+++ b/node_modules/grunt-legacy-log/node_modules/underscore.string/package.json
@@ -0,0 +1,132 @@
+{
+ "_args": [
+ [
+ {
+ "raw": "underscore.string@~2.3.3",
+ "scope": null,
+ "escapedName": "underscore.string",
+ "name": "underscore.string",
+ "rawSpec": "~2.3.3",
+ "spec": ">=2.3.3 <2.4.0",
+ "type": "range"
+ },
+ "/home/vagrant/projects/legislature-tracker/node_modules/grunt-legacy-log"
+ ]
+ ],
+ "_from": "underscore.string@>=2.3.3 <2.4.0",
+ "_id": "underscore.string@2.3.3",
+ "_inCache": true,
+ "_location": "/grunt-legacy-log/underscore.string",
+ "_npmUser": {
+ "name": "epeli",
+ "email": "esa-matti@suuronen.org"
+ },
+ "_npmVersion": "1.2.32",
+ "_phantomChildren": {},
+ "_requested": {
+ "raw": "underscore.string@~2.3.3",
+ "scope": null,
+ "escapedName": "underscore.string",
+ "name": "underscore.string",
+ "rawSpec": "~2.3.3",
+ "spec": ">=2.3.3 <2.4.0",
+ "type": "range"
+ },
+ "_requiredBy": [
+ "/grunt-legacy-log"
+ ],
+ "_resolved": "https://registry.npmjs.org/underscore.string/-/underscore.string-2.3.3.tgz",
+ "_shasum": "71c08bf6b428b1133f37e78fa3a21c82f7329b0d",
+ "_shrinkwrap": null,
+ "_spec": "underscore.string@~2.3.3",
+ "_where": "/home/vagrant/projects/legislature-tracker/node_modules/grunt-legacy-log",
+ "bugs": {
+ "url": "https://github.com/epeli/underscore.string/issues"
+ },
+ "contributors": [
+ {
+ "name": "Esa-Matti Suuronen",
+ "email": "esa-matti@suuronen.org",
+ "url": "http://esa-matti.suuronen.org/"
+ },
+ {
+ "name": "Edward Tsech",
+ "email": "edtsech@gmail.com"
+ },
+ {
+ "name": "Pavel Pravosud",
+ "email": "pavel@pravosud.com",
+ "url": ""
+ },
+ {
+ "name": "Sasha Koss",
+ "email": "kossnocorp@gmail.com",
+ "url": "http://koss.nocorp.me/"
+ },
+ {
+ "name": "Vladimir Dronnikov",
+ "email": "dronnikov@gmail.com"
+ },
+ {
+ "name": "Pete Kruckenberg",
+ "email": "https://github.com/kruckenb",
+ "url": ""
+ },
+ {
+ "name": "Paul Chavard",
+ "email": "paul@chavard.net",
+ "url": ""
+ },
+ {
+ "name": "Ed Finkler",
+ "email": "coj@funkatron.com",
+ "url": ""
+ }
+ ],
+ "dependencies": {},
+ "description": "String manipulation extensions for Underscore.js javascript library.",
+ "devDependencies": {},
+ "directories": {
+ "lib": "./lib"
+ },
+ "dist": {
+ "shasum": "71c08bf6b428b1133f37e78fa3a21c82f7329b0d",
+ "tarball": "https://registry.npmjs.org/underscore.string/-/underscore.string-2.3.3.tgz"
+ },
+ "engines": {
+ "node": "*"
+ },
+ "homepage": "http://epeli.github.com/underscore.string/",
+ "keywords": [
+ "underscore",
+ "string"
+ ],
+ "licenses": [
+ {
+ "type": "MIT"
+ }
+ ],
+ "main": "./lib/underscore.string",
+ "maintainers": [
+ {
+ "name": "edtsech",
+ "email": "edtsech@gmail.com"
+ },
+ {
+ "name": "rwz",
+ "email": "rwz@duckroll.ru"
+ },
+ {
+ "name": "epeli",
+ "email": "esa-matti@suuronen.org"
+ }
+ ],
+ "name": "underscore.string",
+ "optionalDependencies": {},
+ "readme": "ERROR: No README data found!",
+ "repository": {
+ "type": "git",
+ "url": "git+https://github.com/epeli/underscore.string.git"
+ },
+ "version": "2.3.3"
+}
diff --git a/node_modules/grunt-legacy-log/node_modules/underscore.string/test/run-qunit.js b/node_modules/grunt-legacy-log/node_modules/underscore.string/test/run-qunit.js
new file mode 100644
index 0000000..44a2167
--- /dev/null
+++ b/node_modules/grunt-legacy-log/node_modules/underscore.string/test/run-qunit.js
@@ -0,0 +1,45 @@
+function waitFor(test, complete, timeout) {
+ var result, start = new Date().getTime()
+ setInterval(function interval() {
+ if ((new Date().getTime() - start < timeout) && !result) {
+ result = test()
+ } else {
+ if (!result) {
+ phantom.exit(1)
+ } else {
+ complete()
+ clearInterval(interval)
+ }
+ }
+ }, 100)
+}
+
+
+var fs = require('fs'), page = require('webpage').create();
+var url = 'file://localhost' + fs.workingDirectory + '/' + phantom.args[0];
+
+page.onConsoleMessage = function(msg) {
+ console.log(msg)
+}
+
+page.open(url, function(status) {
+ waitFor(function() {
+ return page.evaluate(function(){
+ var el = document.getElementById('qunit-testresult')
+ return el && el.innerText.match('completed')
+ })
+ }, function() {
+ var failures = page.evaluate(function() {
+ var el = document.getElementById('qunit-testresult'),
+ fails = document.getElementsByClassName('fail')
+
+ for (var i = 0; i < fails.length; i++)
+ console.log(fails[i].innerText)
+
+ console.log(el.innerText)
+
+ return parseInt(el.getElementsByClassName('failed')[0].innerHTML)
+ })
+ phantom.exit(failures > 0 ? 1 : 0)
+ }, 10000)
+})
\ No newline at end of file
diff --git a/node_modules/grunt-legacy-log/node_modules/underscore.string/test/speed.js b/node_modules/grunt-legacy-log/node_modules/underscore.string/test/speed.js
new file mode 100644
index 0000000..9ceeea7
--- /dev/null
+++ b/node_modules/grunt-legacy-log/node_modules/underscore.string/test/speed.js
@@ -0,0 +1,148 @@
+(function() {
+
+ JSLitmus.test('levenshtein', function() {
+ return [
+ _.levenshtein('pineapple', 'potato'),
+ _.levenshtein('seven', 'eight'),
+ _.levenshtein('the very same string', 'the very same string'),
+ _.levenshtein('very very very long string', 'something completely different')
+ ];
+ });
+
+
+ JSLitmus.test('trimNoNative', function() {
+ return _.trim(" foobar ", " ");
+ });
+
+ JSLitmus.test('trim', function() {
+ return _.trim(" foobar ");
+ });
+
+ JSLitmus.test('trim object-oriented', function() {
+ return _(" foobar ").trim();
+ });
+
+ JSLitmus.test('trim jQuery', function() {
+ return jQuery.trim(" foobar ");
+ });
+
+ JSLitmus.test('ltrimp', function() {
+ return _.ltrim(" foobar ", " ");
+ });
+
+ JSLitmus.test('rtrimp', function() {
+ return _.rtrim(" foobar ", " ");
+ });
+
+ JSLitmus.test('startsWith', function() {
+ return _.startsWith("foobar", "foo");
+ });
+
+ JSLitmus.test('endsWith', function() {
+ return _.endsWith("foobar", "xx");
+ });
+
+ JSLitmus.test('chop', function(){
+ return _('whitespace').chop(2);
+ });
+
+ JSLitmus.test('count', function(){
+ return _('Hello worls').count('l');
+ });
+
+ JSLitmus.test('insert', function() {
+ return _('Hello ').insert(6, 'world');
+ });
+
+ JSLitmus.test('splice', function() {
+ return _('https://edtsech@bitbucket.org/edtsech/underscore.strings').splice(30, 7, 'epeli');
+ });
+
+ JSLitmus.test('succ', function(){
+ var let = 'a', alphabet = [];
+
+ for (var i=0; i < 26; i++) {
+ alphabet.push(let);
+ let = _(let).succ();
+ }
+
+ return alphabet;
+ });
+
+ JSLitmus.test('titleize', function(){
+ return _('the titleize string method').titleize();
+ });
+
+ JSLitmus.test('truncate', function(){
+ return _('Hello world').truncate(5);
+ });
+
+ JSLitmus.test('prune', function(){
+ return _('Hello world').prune(5);
+ });
+
+ JSLitmus.test('isBlank', function(){
+ return _('').isBlank();
+ });
+
+ JSLitmus.test('escapeHTML', function(){
+ _('Blah blah blah
').escapeHTML();
+ });
+
+ JSLitmus.test('unescapeHTML', function(){
+ _('<div>Blah blah blah</div>').unescapeHTML();
+ });
+
+ JSLitmus.test('reverse', function(){
+ _('Hello World').reverse();
+ });
+
+ JSLitmus.test('pad default', function(){
+ _('foo').pad(12);
+ });
+
+ JSLitmus.test('pad hash left', function(){
+ _('foo').pad(12, '#');
+ });
+
+ JSLitmus.test('pad hash right', function(){
+ _('foo').pad(12, '#', 'right');
+ });
+
+ JSLitmus.test('pad hash both', function(){
+ _('foo').pad(12, '#', 'both');
+ });
+
+ JSLitmus.test('pad hash both longPad', function(){
+ _('foo').pad(12, 'f00f00f00', 'both');
+ });
+
+ JSLitmus.test('toNumber', function(){
+ _('10.232323').toNumber(2);
+ });
+
+ JSLitmus.test('strRight', function(){
+ _('aaa_bbb_ccc').strRight('_');
+ });
+
+ JSLitmus.test('strRightBack', function(){
+ _('aaa_bbb_ccc').strRightBack('_');
+ });
+
+ JSLitmus.test('strLeft', function(){
+ _('aaa_bbb_ccc').strLeft('_');
+ });
+
+ JSLitmus.test('strLeftBack', function(){
+ _('aaa_bbb_ccc').strLeftBack('_');
+ });
+
+ JSLitmus.test('join', function(){
+ _('separator').join(1, 2, 3, 4, 5, 6, 7, 8, 'foo', 'bar', 'lol', 'wut');
+ });
+
+ JSLitmus.test('slugify', function(){
+ _("Un éléphant à l'orée du bois").slugify();
+ });
+
+})();
diff --git a/node_modules/grunt-legacy-log/node_modules/underscore.string/test/strings.js b/node_modules/grunt-legacy-log/node_modules/underscore.string/test/strings.js
new file mode 100644
index 0000000..77364f2
--- /dev/null
+++ b/node_modules/grunt-legacy-log/node_modules/underscore.string/test/strings.js
@@ -0,0 +1,685 @@
+$(document).ready(function() {
+
+ // Include Underscore.string methods to Underscore namespace
+ _.mixin(_.str.exports());
+
+ module('String extensions');
+
+ test('Strings: naturalSort', function() {
+ var arr = ['foo2', 'foo1', 'foo10', 'foo30', 'foo100', 'foo10bar'],
+ sorted = ['foo1', 'foo2', 'foo10', 'foo10bar', 'foo30', 'foo100'];
+ deepEqual(arr.sort(_.naturalCmp), sorted);
+ });
+
+ test('Strings: trim', function() {
+ equal(_.trim(123), '123', 'Non string');
+ equal(_(' foo').trim(), 'foo');
+ equal(_('foo ').trim(), 'foo');
+ equal(_(' foo ').trim(), 'foo');
+ equal(_(' foo ').trim(), 'foo');
+ equal(_(' foo ').trim(' '), 'foo', 'Manually set whitespace');
+ equal(_('\t foo \t ').trim(/\s/), 'foo', 'Manually set RegExp /\\s+/');
+
+ equal(_('ffoo').trim('f'), 'oo');
+ equal(_('ooff').trim('f'), 'oo');
+ equal(_('ffooff').trim('f'), 'oo');
+
+
+ equal(_('_-foobar-_').trim('_-'), 'foobar');
+
+ equal(_('http://foo/').trim('/'), 'http://foo');
+ equal(_('c:\\').trim('\\'), 'c:');
+
+ equal(_(123).trim(), '123');
+ equal(_(123).trim(3), '12');
+ equal(_('').trim(), '', 'Trim empty string should return empty string');
+ equal(_(null).trim(), '', 'Trim null should return empty string');
+ equal(_(undefined).trim(), '', 'Trim undefined should return empty string');
+ });
+
+ test('String: levenshtein', function() {
+ equal(_.levenshtein('Godfather', 'Godfather'), 0);
+ equal(_.levenshtein('Godfather', 'Godfathe'), 1);
+ equal(_.levenshtein('Godfather', 'odfather'), 1);
+ equal(_.levenshtein('Godfather', 'Gdfthr'), 3);
+ equal(_.levenshtein('seven', 'eight'), 5);
+ equal(_.levenshtein('123', 123), 0);
+ equal(_.levenshtein(321, '321'), 0);
+ equal(_.levenshtein('lol', null), 3);
+ equal(_.levenshtein('lol'), 3);
+ equal(_.levenshtein(null, 'lol'), 3);
+ equal(_.levenshtein(undefined, 'lol'), 3);
+ equal(_.levenshtein(), 0);
+ });
+
+ test('Strings: ltrim', function() {
+ equal(_(' foo').ltrim(), 'foo');
+ equal(_(' foo').ltrim(), 'foo');
+ equal(_('foo ').ltrim(), 'foo ');
+ equal(_(' foo ').ltrim(), 'foo ');
+ equal(_('').ltrim(), '', 'ltrim empty string should return empty string');
+ equal(_(null).ltrim(), '', 'ltrim null should return empty string');
+ equal(_(undefined).ltrim(), '', 'ltrim undefined should return empty string');
+
+ equal(_('ffoo').ltrim('f'), 'oo');
+ equal(_('ooff').ltrim('f'), 'ooff');
+ equal(_('ffooff').ltrim('f'), 'ooff');
+
+ equal(_('_-foobar-_').ltrim('_-'), 'foobar-_');
+
+ equal(_(123).ltrim(1), '23');
+ });
+
+ test('Strings: rtrim', function() {
+ equal(_('http://foo/').rtrim('/'), 'http://foo', 'clean trailing slash');
+ equal(_(' foo').rtrim(), ' foo');
+ equal(_('foo ').rtrim(), 'foo');
+ equal(_('foo ').rtrim(), 'foo');
+ equal(_('foo bar ').rtrim(), 'foo bar');
+ equal(_(' foo ').rtrim(), ' foo');
+
+ equal(_('ffoo').rtrim('f'), 'ffoo');
+ equal(_('ooff').rtrim('f'), 'oo');
+ equal(_('ffooff').rtrim('f'), 'ffoo');
+
+ equal(_('_-foobar-_').rtrim('_-'), '_-foobar');
+
+ equal(_(123).rtrim(3), '12');
+ equal(_('').rtrim(), '', 'rtrim empty string should return empty string');
+ equal(_(null).rtrim(), '', 'rtrim null should return empty string');
+ });
+
+ test('Strings: capitalize', function() {
+ equal(_('fabio').capitalize(), 'Fabio', 'First letter is upper case');
+ equal(_.capitalize('fabio'), 'Fabio', 'First letter is upper case');
+ equal(_.capitalize('FOO'), 'FOO', 'Other letters unchanged');
+ equal(_(123).capitalize(), '123', 'Non string');
+ equal(_.capitalize(''), '', 'Capitalizing empty string returns empty string');
+ equal(_.capitalize(null), '', 'Capitalizing null returns empty string');
+ equal(_.capitalize(undefined), '', 'Capitalizing undefined returns empty string');
+ });
+
+ test('Strings: join', function() {
+ equal(_.join('', 'foo', 'bar'), 'foobar', 'basic join');
+ equal(_.join('', 1, 'foo', 2), '1foo2', 'join numbers and strings');
+ equal(_.join(' ','foo', 'bar'), 'foo bar', 'join with spaces');
+ equal(_.join('1', '2', '2'), '212', 'join number strings');
+ equal(_.join(1, 2, 2), '212', 'join numbers');
+ equal(_.join('','foo', null), 'foo', 'join null with string returns string');
+ equal(_.join(null,'foo', 'bar'), 'foobar', 'join strings with null returns string');
+ equal(_(' ').join('foo', 'bar'), 'foo bar', 'join object oriented');
+ });
+
+ test('Strings: reverse', function() {
+ equal(_.str.reverse('foo'), 'oof' );
+ equal(_.str.reverse('foobar'), 'raboof' );
+ equal(_.str.reverse('foo bar'), 'rab oof' );
+ equal(_.str.reverse('saippuakauppias'), 'saippuakauppias' );
+ equal(_.str.reverse(123), '321', 'Non string');
+ equal(_.str.reverse(123.45), '54.321', 'Non string');
+ equal(_.str.reverse(''), '', 'reversing empty string returns empty string' );
+ equal(_.str.reverse(null), '', 'reversing null returns empty string' );
+ equal(_.str.reverse(undefined), '', 'reversing undefined returns empty string' );
+ });
+
+ test('Strings: clean', function() {
+ equal(_(' foo bar ').clean(), 'foo bar');
+ equal(_(123).clean(), '123');
+ equal(_('').clean(), '', 'claning empty string returns empty string');
+ equal(_(null).clean(), '', 'claning null returns empty string');
+ equal(_(undefined).clean(), '', 'claning undefined returns empty string');
+ });
+
+ test('Strings: sprintf', function() {
+ // Should be very tested function already. Thanks to
+ // http://www.diveintojavascript.com/projects/sprintf-for-javascript
+ equal(_.sprintf('Hello %s', 'me'), 'Hello me', 'basic');
+ equal(_('Hello %s').sprintf('me'), 'Hello me', 'object');
+ equal(_('hello %s').chain().sprintf('me').capitalize().value(), 'Hello me', 'Chaining works');
+ equal(_.sprintf('%.1f', 1.22222), '1.2', 'round');
+ equal(_.sprintf('%.1f', 1.17), '1.2', 'round 2');
+ equal(_.sprintf('%(id)d - %(name)s', {id: 824, name: 'Hello World'}), '824 - Hello World', 'Named replacements work');
+ equal(_.sprintf('%(args[0].id)d - %(args[1].name)s', {args: [{id: 824}, {name: 'Hello World'}]}), '824 - Hello World', 'Named replacements with arrays work');
+ });
+
+
+ test('Strings: vsprintf', function() {
+ equal(_.vsprintf('Hello %s', ['me']), 'Hello me', 'basic');
+ equal(_('Hello %s').vsprintf(['me']), 'Hello me', 'object');
+ equal(_('hello %s').chain().vsprintf(['me']).capitalize().value(), 'Hello me', 'Chaining works');
+ equal(_.vsprintf('%.1f', [1.22222]), '1.2', 'round');
+ equal(_.vsprintf('%.1f', [1.17]), '1.2', 'round 2');
+ equal(_.vsprintf('%(id)d - %(name)s', [{id: 824, name: 'Hello World'}]), '824 - Hello World', 'Named replacement works');
+ equal(_.vsprintf('%(args[0].id)d - %(args[1].name)s', [{args: [{id: 824}, {name: 'Hello World'}]}]), '824 - Hello World', 'Named replacement with arrays works');
+ });
+
+ test('Strings: startsWith', function() {
+ ok(_('foobar').startsWith('foo'), 'foobar starts with foo');
+ ok(!_('oobar').startsWith('foo'), 'oobar does not start with foo');
+ ok(_(12345).startsWith(123), '12345 starts with 123');
+ ok(!_(2345).startsWith(123), '2345 does not start with 123');
+ ok(_('').startsWith(''), 'empty string starts with empty string');
+ ok(_(null).startsWith(''), 'null starts with empty string');
+ ok(!_(null).startsWith('foo'), 'null starts with foo');
+ });
+
+ test('Strings: endsWith', function() {
+ ok(_('foobar').endsWith('bar'), 'foobar ends with bar');
+ ok(_.endsWith('foobar', 'bar'), 'foobar ends with bar');
+ ok(_.endsWith('00018-0000062.Plone.sdh264.1a7264e6912a91aa4a81b64dc5517df7b8875994.mp4', 'mp4'), 'endsWith .mp4');
+ ok(!_('fooba').endsWith('bar'), 'fooba does not end with bar');
+ ok(_.endsWith(12345, 45), '12345 ends with 45');
+ ok(!_.endsWith(12345, 6), '12345 does not end with 6');
+ ok(_('').endsWith(''), 'empty string ends with empty string');
+ ok(_(null).endsWith(''), 'null ends with empty string');
+ ok(!_(null).endsWith('foo'), 'null ends with foo');
+ });
+
+ test('Strings: include', function() {
+ ok(_.str.include('foobar', 'bar'), 'foobar includes bar');
+ ok(!_.str.include('foobar', 'buzz'), 'foobar does not includes buzz');
+ ok(_.str.include(12345, 34), '12345 includes 34');
+ ok(!_.str.contains(12345, 6), '12345 does not includes 6');
+ ok(!_.str.include('', 34), 'empty string includes 34');
+ ok(!_.str.include(null, 34), 'null includes 34');
+ ok(_.str.include(null, ''), 'null includes empty string');
+ });
+
+ test('String: chop', function(){
+ ok(_('whitespace').chop(2).length === 5, 'output [wh, it, es, pa, ce]');
+ ok(_('whitespace').chop(3).length === 4, 'output [whi, tes, pac, e]');
+ ok(_('whitespace').chop()[0].length === 10, 'output [whitespace]');
+ ok(_(12345).chop(1).length === 5, 'output [1, 2, 3, 4, 5]');
+ });
+
+ test('String: clean', function(){
+ equal(_.clean(' foo bar '), 'foo bar');
+ equal(_.clean(''), '');
+ equal(_.clean(null), '');
+ equal(_.clean(1), '1');
+ });
+
+ test('String: count', function(){
+ equal(_('Hello world').count('l'), 3);
+ equal(_('Hello world').count('Hello'), 1);
+ equal(_('Hello world').count('foo'), 0);
+ equal(_('x.xx....x.x').count('x'), 5);
+ equal(_('').count('x'), 0);
+ equal(_(null).count('x'), 0);
+ equal(_(undefined).count('x'), 0);
+ equal(_(12345).count(1), 1);
+ equal(_(11345).count(1), 2);
+ });
+
+ test('String: insert', function(){
+ equal(_('Hello ').insert(6, 'Jessy'), 'Hello Jessy');
+ equal(_('Hello ').insert(100, 'Jessy'), 'Hello Jessy');
+ equal(_('').insert(100, 'Jessy'), 'Jessy');
+ equal(_(null).insert(100, 'Jessy'), 'Jessy');
+ equal(_(undefined).insert(100, 'Jessy'), 'Jessy');
+ equal(_(12345).insert(6, 'Jessy'), '12345Jessy');
+ });
+
+ test('String: splice', function(){
+ equal(_('https://edtsech@bitbucket.org/edtsech/underscore.strings').splice(30, 7, 'epeli'),
+ 'https://edtsech@bitbucket.org/epeli/underscore.strings');
+ equal(_.splice(12345, 1, 2, 321), '132145', 'Non strings');
+ });
+
+ test('String: succ', function(){
+ equal(_('a').succ(), 'b');
+ equal(_('A').succ(), 'B');
+ equal(_('+').succ(), ',');
+ equal(_(1).succ(), '2');
+ });
+
+ test('String: titleize', function(){
+ equal(_('the titleize string method').titleize(), 'The Titleize String Method');
+ equal(_('the titleize string method').titleize(), 'The Titleize String Method');
+ equal(_('').titleize(), '', 'Titleize empty string returns empty string');
+ equal(_(null).titleize(), '', 'Titleize null returns empty string');
+ equal(_(undefined).titleize(), '', 'Titleize undefined returns empty string');
+ equal(_('let\'s have some fun').titleize(), 'Let\'s Have Some Fun');
+ equal(_('a-dash-separated-string').titleize(), 'A-Dash-Separated-String');
+ equal(_('A-DASH-SEPARATED-STRING').titleize(), 'A-Dash-Separated-String');
+ equal(_(123).titleize(), '123');
+ });
+
+ test('String: camelize', function(){
+ equal(_('the_camelize_string_method').camelize(), 'theCamelizeStringMethod');
+ equal(_('-the-camelize-string-method').camelize(), 'TheCamelizeStringMethod');
+ equal(_('the camelize string method').camelize(), 'theCamelizeStringMethod');
+ equal(_(' the camelize string method').camelize(), 'theCamelizeStringMethod');
+ equal(_('the camelize string method').camelize(), 'theCamelizeStringMethod');
+ equal(_('').camelize(), '', 'Camelize empty string returns empty string');
+ equal(_(null).camelize(), '', 'Camelize null returns empty string');
+ equal(_(undefined).camelize(), '', 'Camelize undefined returns empty string');
+ equal(_(123).camelize(), '123');
+ });
+
+ test('String: underscored', function(){
+ equal(_('the-underscored-string-method').underscored(), 'the_underscored_string_method');
+ equal(_('theUnderscoredStringMethod').underscored(), 'the_underscored_string_method');
+ equal(_('TheUnderscoredStringMethod').underscored(), 'the_underscored_string_method');
+ equal(_(' the underscored string method').underscored(), 'the_underscored_string_method');
+ equal(_('').underscored(), '');
+ equal(_(null).underscored(), '');
+ equal(_(undefined).underscored(), '');
+ equal(_(123).underscored(), '123');
+ });
+
+ test('String: dasherize', function(){
+ equal(_('the_dasherize_string_method').dasherize(), 'the-dasherize-string-method');
+ equal(_('TheDasherizeStringMethod').dasherize(), '-the-dasherize-string-method');
+ equal(_('thisIsATest').dasherize(), 'this-is-a-test');
+ equal(_('this Is A Test').dasherize(), 'this-is-a-test');
+ equal(_('thisIsATest123').dasherize(), 'this-is-a-test123');
+ equal(_('123thisIsATest').dasherize(), '123this-is-a-test');
+ equal(_('the dasherize string method').dasherize(), 'the-dasherize-string-method');
+ equal(_('the dasherize string method ').dasherize(), 'the-dasherize-string-method');
+ equal(_('téléphone').dasherize(), 'téléphone');
+ equal(_('foo$bar').dasherize(), 'foo$bar');
+ equal(_('').dasherize(), '');
+ equal(_(null).dasherize(), '');
+ equal(_(undefined).dasherize(), '');
+ equal(_(123).dasherize(), '123');
+ });
+
+ test('String: camelize', function(){
+ equal(_.camelize('-moz-transform'), 'MozTransform');
+ equal(_.camelize('webkit-transform'), 'webkitTransform');
+ equal(_.camelize('under_scored'), 'underScored');
+ equal(_.camelize(' with spaces'), 'withSpaces');
+ equal(_('').camelize(), '');
+ equal(_(null).camelize(), '');
+ equal(_(undefined).camelize(), '');
+ equal(_("_som eWeird---name-").camelize(), 'SomEWeirdName');
+ });
+
+ test('String: join', function(){
+ equal(_.join(1, 2, 3, 4), '21314');
+ equal(_.join('|', 'foo', 'bar', 'baz'), 'foo|bar|baz');
+ equal(_.join('',2,3,null), '23');
+ equal(_.join(null,2,3), '23');
+ });
+
+ test('String: classify', function(){
+ equal(_.classify(1), '1');
+ equal(_('some_class_name').classify(), 'SomeClassName');
+ equal(_('my wonderfull class_name').classify(), 'MyWonderfullClassName');
+ equal(_('my wonderfull.class.name').classify(), 'MyWonderfullClassName');
+ });
+
+ test('String: humanize', function(){
+ equal(_('the_humanize_string_method').humanize(), 'The humanize string method');
+ equal(_('ThehumanizeStringMethod').humanize(), 'Thehumanize string method');
+ equal(_('the humanize string method').humanize(), 'The humanize string method');
+ equal(_('the humanize_id string method_id').humanize(), 'The humanize id string method');
+ equal(_('the humanize string method ').humanize(), 'The humanize string method');
+ equal(_(' capitalize dash-CamelCase_underscore trim ').humanize(), 'Capitalize dash camel case underscore trim');
+ equal(_(123).humanize(), '123');
+ equal(_('').humanize(), '');
+ equal(_(null).humanize(), '');
+ equal(_(undefined).humanize(), '');
+ });
+
+ test('String: truncate', function(){
+ equal(_('Hello world').truncate(6, 'read more'), 'Hello read more');
+ equal(_('Hello world').truncate(5), 'Hello...');
+ equal(_('Hello').truncate(10), 'Hello');
+ equal(_('').truncate(10), '');
+ equal(_(null).truncate(10), '');
+ equal(_(undefined).truncate(10), '');
+ equal(_(1234567890).truncate(5), '12345...');
+ });
+
+ test('String: prune', function(){
+ equal(_('Hello, cruel world').prune(6, ' read more'), 'Hello read more');
+ equal(_('Hello, world').prune(5, 'read a lot more'), 'Hello, world');
+ equal(_('Hello, world').prune(5), 'Hello...');
+ equal(_('Hello, world').prune(8), 'Hello...');
+ equal(_('Hello, cruel world').prune(15), 'Hello, cruel...');
+ equal(_('Hello world').prune(22), 'Hello world');
+ equal(_('Привет, жестокий мир').prune(6, ' read more'), 'Привет read more');
+ equal(_('Привет, мир').prune(6, 'read a lot more'), 'Привет, мир');
+ equal(_('Привет, мир').prune(6), 'Привет...');
+ equal(_('Привет, мир').prune(8), 'Привет...');
+ equal(_('Привет, жестокий мир').prune(16), 'Привет, жестокий...');
+ equal(_('Привет, мир').prune(22), 'Привет, мир');
+ equal(_('alksjd!!!!!!....').prune(100, ''), 'alksjd!!!!!!....');
+ equal(_(123).prune(10), '123');
+ equal(_(123).prune(1, 321), '321');
+ equal(_('').prune(5), '');
+ equal(_(null).prune(5), '');
+ equal(_(undefined).prune(5), '');
+ });
+
+ test('String: isBlank', function(){
+ ok(_('').isBlank());
+ ok(_(' ').isBlank());
+ ok(_('\n').isBlank());
+ ok(!_('a').isBlank());
+ ok(!_('0').isBlank());
+ ok(!_(0).isBlank());
+ ok(_('').isBlank());
+ ok(_(null).isBlank());
+ ok(_(undefined).isBlank());
+ });
+
+ test('String: escapeRegExp', function(){
+ equal(_.escapeRegExp(/hello(?=\sworld)/.source), 'hello\\(\\?\\=\\\\sworld\\)', 'with lookahead');
+ equal(_.escapeRegExp(/hello(?!\shell)/.source), 'hello\\(\\?\\!\\\\shell\\)', 'with negative lookahead');
+ });
+
+ test('String: escapeHTML', function(){
+ equal(_('Blah & "blah" & \'blah\'
').escapeHTML(),
+ '<div>Blah & "blah" & 'blah'</div>');
+ equal(_('<').escapeHTML(), '<');
+ equal(_(5).escapeHTML(), '5');
+ equal(_('').escapeHTML(), '');
+ equal(_(null).escapeHTML(), '');
+ equal(_(undefined).escapeHTML(), '');
+ });
+
+ test('String: unescapeHTML', function(){
+ equal(_('<div>Blah & "blah" & 'blah'</div>').unescapeHTML(),
+ 'Blah & "blah" & \'blah\'
');
+ equal(_('<').unescapeHTML(), '<');
+ equal(_(''').unescapeHTML(), '\'');
+ equal(_(''').unescapeHTML(), '\'');
+ equal(_(''').unescapeHTML(), '\'');
+ equal(_('J').unescapeHTML(), 'J');
+ equal(_('J').unescapeHTML(), 'J');
+ equal(_('J').unescapeHTML(), 'J');
+ equal(_('&_#39;').unescapeHTML(), '&_#39;');
+ equal(_(''_;').unescapeHTML(), ''_;');
+ equal(_('&').unescapeHTML(), '&');
+ equal(_('&').unescapeHTML(), '&');
+ equal(_('').unescapeHTML(), '');
+ equal(_(null).unescapeHTML(), '');
+ equal(_(undefined).unescapeHTML(), '');
+ equal(_(5).unescapeHTML(), '5');
+ // equal(_(undefined).unescapeHTML(), '');
+ });
+
+ test('String: words', function() {
+ deepEqual(_('I love you!').words(), ['I', 'love', 'you!']);
+ deepEqual(_(' I love you! ').words(), ['I', 'love', 'you!']);
+ deepEqual(_('I_love_you!').words('_'), ['I', 'love', 'you!']);
+ deepEqual(_('I-love-you!').words(/-/), ['I', 'love', 'you!']);
+ deepEqual(_(123).words(), ['123'], '123 number has one word "123".');
+ deepEqual(_(0).words(), ['0'], 'Zero number has one word "0".');
+ deepEqual(_('').words(), [], 'Empty strings has no words.');
+ deepEqual(_(' ').words(), [], 'Blank strings has no words.');
+ deepEqual(_(null).words(), [], 'null has no words.');
+ deepEqual(_(undefined).words(), [], 'undefined has no words.');
+ });
+
+ test('String: chars', function() {
+ equal(_('Hello').chars().length, 5);
+ equal(_(123).chars().length, 3);
+ equal(_('').chars().length, 0);
+ equal(_(null).chars().length, 0);
+ equal(_(undefined).chars().length, 0);
+ });
+
+ test('String: swapCase', function(){
+ equal(_('AaBbCcDdEe').swapCase(), 'aAbBcCdDeE');
+ equal(_('Hello World').swapCase(), 'hELLO wORLD');
+ equal(_('').swapCase(), '');
+ equal(_(null).swapCase(), '');
+ equal(_(undefined).swapCase(), '');
+ });
+
+ test('String: lines', function() {
+ equal(_('Hello\nWorld').lines().length, 2);
+ equal(_('Hello World').lines().length, 1);
+ equal(_(123).lines().length, 1);
+ equal(_('').lines().length, 1);
+ equal(_(null).lines().length, 0);
+ equal(_(undefined).lines().length, 0);
+ });
+
+ test('String: pad', function() {
+ equal(_('1').pad(8), ' 1');
+ equal(_(1).pad(8), ' 1');
+ equal(_('1').pad(8, '0'), '00000001');
+ equal(_('1').pad(8, '0', 'left'), '00000001');
+ equal(_('1').pad(8, '0', 'right'), '10000000');
+ equal(_('1').pad(8, '0', 'both'), '00001000');
+ equal(_('foo').pad(8, '0', 'both'), '000foo00');
+ equal(_('foo').pad(7, '0', 'both'), '00foo00');
+ equal(_('foo').pad(7, '!@$%dofjrofj', 'both'), '!!foo!!');
+ equal(_('').pad(2), ' ');
+ equal(_(null).pad(2), ' ');
+ equal(_(undefined).pad(2), ' ');
+ });
+
+ test('String: lpad', function() {
+ equal(_('1').lpad(8), ' 1');
+ equal(_(1).lpad(8), ' 1');
+ equal(_('1').lpad(8, '0'), '00000001');
+ equal(_('1').lpad(8, '0', 'left'), '00000001');
+ equal(_('').lpad(2), ' ');
+ equal(_(null).lpad(2), ' ');
+ equal(_(undefined).lpad(2), ' ');
+ });
+
+ test('String: rpad', function() {
+ equal(_('1').rpad(8), '1 ');
+ equal(_(1).lpad(8), ' 1');
+ equal(_('1').rpad(8, '0'), '10000000');
+ equal(_('foo').rpad(8, '0'), 'foo00000');
+ equal(_('foo').rpad(7, '0'), 'foo0000');
+ equal(_('').rpad(2), ' ');
+ equal(_(null).rpad(2), ' ');
+ equal(_(undefined).rpad(2), ' ');
+ });
+
+ test('String: lrpad', function() {
+ equal(_('1').lrpad(8), ' 1 ');
+ equal(_(1).lrpad(8), ' 1 ');
+ equal(_('1').lrpad(8, '0'), '00001000');
+ equal(_('foo').lrpad(8, '0'), '000foo00');
+ equal(_('foo').lrpad(7, '0'), '00foo00');
+ equal(_('foo').lrpad(7, '!@$%dofjrofj'), '!!foo!!');
+ equal(_('').lrpad(2), ' ');
+ equal(_(null).lrpad(2), ' ');
+ equal(_(undefined).lrpad(2), ' ');
+ });
+
+ test('String: toNumber', function() {
+ deepEqual(_('not a number').toNumber(), NaN);
+ equal(_(0).toNumber(), 0);
+ equal(_('0').toNumber(), 0);
+ equal(_('0.0').toNumber(), 0);
+ equal(_('0.1').toNumber(), 0);
+ equal(_('0.1').toNumber(1), 0.1);
+ equal(_(' 0.1 ').toNumber(1), 0.1);
+ equal(_('0000').toNumber(), 0);
+ equal(_('2.345').toNumber(), 2);
+ equal(_('2.345').toNumber(NaN), 2);
+ equal(_('2.345').toNumber(2), 2.35);
+ equal(_('2.344').toNumber(2), 2.34);
+ equal(_('2').toNumber(2), 2.00);
+ equal(_(2).toNumber(2), 2.00);
+ equal(_(-2).toNumber(), -2);
+ equal(_('-2').toNumber(), -2);
+ equal(_('').toNumber(), 0);
+ equal(_(null).toNumber(), 0);
+ equal(_(undefined).toNumber(), 0);
+ });
+
+ test('String: numberFormat', function() {
+ equal(_.numberFormat(9000), '9,000');
+ equal(_.numberFormat(9000, 0), '9,000');
+ equal(_.numberFormat(9000, 0, '', ''), '9000');
+ equal(_.numberFormat(90000, 2), '90,000.00');
+ equal(_.numberFormat(1000.754), '1,001');
+ equal(_.numberFormat(1000.754, 2), '1,000.75');
+ equal(_.numberFormat(1000.754, 0, ',', '.'), '1.001');
+ equal(_.numberFormat(1000.754, 2, ',', '.'), '1.000,75');
+ equal(_.numberFormat(1000000.754, 2, ',', '.'), '1.000.000,75');
+ equal(_.numberFormat(1000000000), '1,000,000,000');
+ equal(_.numberFormat(100000000), '100,000,000');
+ equal(_.numberFormat('not number'), '');
+ equal(_.numberFormat(), '');
+ equal(_.numberFormat(null, '.', ','), '');
+ equal(_.numberFormat(undefined, '.', ','), '');
+ equal(_.numberFormat(new Number(5000)), '5,000');
+ });
+
+ test('String: strRight', function() {
+ equal(_('This_is_a_test_string').strRight('_'), 'is_a_test_string');
+ equal(_('This_is_a_test_string').strRight('string'), '');
+ equal(_('This_is_a_test_string').strRight(), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strRight(''), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strRight('-'), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strRight(''), 'This_is_a_test_string');
+ equal(_('').strRight('foo'), '');
+ equal(_(null).strRight('foo'), '');
+ equal(_(undefined).strRight('foo'), '');
+ equal(_(12345).strRight(2), '345');
+ });
+
+ test('String: strRightBack', function() {
+ equal(_('This_is_a_test_string').strRightBack('_'), 'string');
+ equal(_('This_is_a_test_string').strRightBack('string'), '');
+ equal(_('This_is_a_test_string').strRightBack(), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strRightBack(''), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strRightBack('-'), 'This_is_a_test_string');
+ equal(_('').strRightBack('foo'), '');
+ equal(_(null).strRightBack('foo'), '');
+ equal(_(undefined).strRightBack('foo'), '');
+ equal(_(12345).strRightBack(2), '345');
+ });
+
+ test('String: strLeft', function() {
+ equal(_('This_is_a_test_string').strLeft('_'), 'This');
+ equal(_('This_is_a_test_string').strLeft('This'), '');
+ equal(_('This_is_a_test_string').strLeft(), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strLeft(''), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strLeft('-'), 'This_is_a_test_string');
+ equal(_('').strLeft('foo'), '');
+ equal(_(null).strLeft('foo'), '');
+ equal(_(undefined).strLeft('foo'), '');
+ equal(_(123454321).strLeft(3), '12');
+ });
+
+ test('String: strLeftBack', function() {
+ equal(_('This_is_a_test_string').strLeftBack('_'), 'This_is_a_test');
+ equal(_('This_is_a_test_string').strLeftBack('This'), '');
+ equal(_('This_is_a_test_string').strLeftBack(), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strLeftBack(''), 'This_is_a_test_string');
+ equal(_('This_is_a_test_string').strLeftBack('-'), 'This_is_a_test_string');
+ equal(_('').strLeftBack('foo'), '');
+ equal(_(null).strLeftBack('foo'), '');
+ equal(_(undefined).strLeftBack('foo'), '');
+ equal(_(123454321).strLeftBack(3), '123454');
+ });
+
+ test('Strings: stripTags', function() {
+ equal(_('a link').stripTags(), 'a link');
+ equal(_('a link
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+