irontask 0.0.2

data/lib/irontask/public/components/mustache/test/_files/reuse_of_enumerables.js

@@ -0,0 +1,6 @@
+({
+  terms: [
+    {name: 't1', index: 0},
+    {name: 't2', index: 1}
+  ]
+})

data/lib/irontask/public/components/mustache/test/_files/reuse_of_enumerables.mustache

@@ -0,0 +1,8 @@
+{{#terms}}
+  {{name}}
+  {{index}}
+{{/terms}}
+{{#terms}}
+  {{name}}
+  {{index}}
+{{/terms}}

data/lib/irontask/public/components/mustache/test/_files/reuse_of_enumerables.txt

@@ -0,0 +1,8 @@
+  t1
+  0
+  t2
+  1
+  t1
+  0
+  t2
+  1

data/lib/irontask/public/components/mustache/test/_files/section_as_context.js

@@ -0,0 +1,10 @@
+({
+  a_object: {
+    title: 'this is an object',
+    description: 'one of its attributes is a list',
+    a_list: [
+      {label: 'listitem1'},
+      {label: 'listitem2'}
+    ]
+  }
+})

data/lib/irontask/public/components/mustache/test/_files/section_as_context.mustache

@@ -0,0 +1,9 @@
+{{#a_object}}
+  <h1>{{title}}</h1>
+  <p>{{description}}</p>
+  <ul>
+    {{#a_list}}
+    <li>{{label}}</li>
+    {{/a_list}}
+  </ul>
+{{/a_object}}

data/lib/irontask/public/components/mustache/test/_files/section_as_context.txt

@@ -0,0 +1,6 @@
+  <h1>this is an object</h1>
+  <p>one of its attributes is a list</p>
+  <ul>
+    <li>listitem1</li>
+    <li>listitem2</li>
+  </ul>

data/lib/irontask/public/components/mustache/test/_files/simple.js

@@ -0,0 +1,8 @@
+({
+  name: "Chris",
+  value: 10000,
+  taxed_value: function () {
+    return this.value - (this.value * 0.4);
+  },
+  in_ca: true
+})

data/lib/irontask/public/components/mustache/test/_files/simple.mustache

@@ -0,0 +1,5 @@
+Hello {{name}}
+You have just won ${{value}}!
+{{#in_ca}}
+Well, ${{ taxed_value }}, after taxes.
+{{/in_ca}}

data/lib/irontask/public/components/mustache/test/_files/simple.txt

@@ -0,0 +1,3 @@
+Hello Chris
+You have just won $10000!
+Well, $6000, after taxes.

data/lib/irontask/public/components/mustache/test/_files/string_as_context.js

@@ -0,0 +1,4 @@
+({
+  a_string: 'aa',
+  a_list: ['a','b','c']
+})

data/lib/irontask/public/components/mustache/test/_files/string_as_context.mustache

@@ -0,0 +1,5 @@
+<ul>
+{{#a_list}}
+    <li><a href="#{{a_string}}/{{.}}">{{.}}</a></li>
+{{/a_list}}
+</ul>

data/lib/irontask/public/components/mustache/test/_files/string_as_context.txt

@@ -0,0 +1,5 @@
+<ul>
+    <li><a href="#aa/a">a</a></li>
+    <li><a href="#aa/b">b</a></li>
+    <li><a href="#aa/c">c</a></li>
+</ul>

data/lib/irontask/public/components/mustache/test/_files/two_in_a_row.js

@@ -0,0 +1,4 @@
+({
+  name: "Joe",
+  greeting: "Welcome"
+})

data/lib/irontask/public/components/mustache/test/_files/two_in_a_row.mustache

@@ -0,0 +1 @@
+{{greeting}}, {{name}}!

data/lib/irontask/public/components/mustache/test/_files/two_in_a_row.txt

@@ -0,0 +1 @@
+Welcome, Joe!

data/lib/irontask/public/components/mustache/test/_files/two_sections.js

@@ -0,0 +1 @@
+({})

data/lib/irontask/public/components/mustache/test/_files/two_sections.mustache

@@ -0,0 +1,4 @@
+{{#foo}}
+{{/foo}}
+{{#bar}}
+{{/bar}}

data/lib/irontask/public/components/mustache/test/_files/unescaped.js

@@ -0,0 +1,5 @@
+({
+  title: function () {
+    return "Bear > Shark";
+  }
+})

data/lib/irontask/public/components/mustache/test/_files/unescaped.mustache

@@ -0,0 +1 @@
+<h1>{{{title}}}</h1>

data/lib/irontask/public/components/mustache/test/_files/unescaped.txt

@@ -0,0 +1 @@
+<h1>Bear > Shark</h1>

data/lib/irontask/public/components/mustache/test/_files/whitespace.js

@@ -0,0 +1,4 @@
+({
+  tag1: "Hello",
+  tag2: "World"
+})

data/lib/irontask/public/components/mustache/test/_files/whitespace.mustache

@@ -0,0 +1,4 @@
+{{tag1}}
+
+
+{{tag2}}.

data/lib/irontask/public/components/mustache/test/_files/whitespace.txt

@@ -0,0 +1,4 @@
+Hello
+
+
+World.

data/lib/irontask/public/components/mustache/test/context-test.js

@@ -0,0 +1,51 @@
+require('./helper');
+var Context = Mustache.Context;
+
+describe('A new Mustache.Context', function () {
+  var context;
+  beforeEach(function () {
+    context = new Context({ name: 'parent', message: 'hi', a: { b: 'b' } });
+  });
+
+  it('is able to lookup properties of its own view', function () {
+    assert.equal(context.lookup('name'), 'parent');
+  });
+
+  it('is able to lookup nested properties of its own view', function () {
+    assert.equal(context.lookup('a.b'), 'b');
+  });
+
+  describe('when pushed', function () {
+    beforeEach(function () {
+      context = context.push({ name: 'child', c: { d: 'd' } });
+    });
+
+    it('returns the child context', function () {
+      assert.equal(context.view.name, 'child');
+      assert.equal(context.parent.view.name, 'parent');
+    });
+
+    it('is able to lookup properties of its own view', function () {
+      assert.equal(context.lookup('name'), 'child');
+    });
+
+    it("is able to lookup properties of the parent context's view", function () {
+      assert.equal(context.lookup('message'), 'hi');
+    });
+
+    it('is able to lookup nested properties of its own view', function () {
+      assert.equal(context.lookup('c.d'), 'd');
+    });
+
+    it('is able to lookup nested properties of its parent view', function () {
+      assert.equal(context.lookup('a.b'), 'b');
+    });
+  });
+});
+
+describe('Mustache.Context.make', function () {
+  it('returns the same object when given a Context', function () {
+    var context = new Context;
+    assert.strictEqual(Context.make(context), context);
+  });
+});

data/lib/irontask/public/components/mustache/test/helper.js

@@ -0,0 +1,2 @@
+assert = require('assert');
+Mustache = require('../mustache');

data/lib/irontask/public/components/mustache/test/parse-test.js

@@ -0,0 +1,106 @@
+require('./helper');
+
+// A map of templates to their expected token output. Tokens are in the format:
+// [type, value, startIndex, endIndex, subTokens].
+var expectations = {
+  ''                                        : [],
+  '{{hi}}'                                  : [ [ 'name', 'hi', 0, 6 ] ],
+  '{{hi.world}}'                            : [ [ 'name', 'hi.world', 0, 12 ] ],
+  '{{hi . world}}'                          : [ [ 'name', 'hi . world', 0, 14 ] ],
+  '{{ hi}}'                                 : [ [ 'name', 'hi', 0, 7 ] ],
+  '{{hi }}'                                 : [ [ 'name', 'hi', 0, 7 ] ],
+  '{{ hi }}'                                : [ [ 'name', 'hi', 0, 8 ] ],
+  '{{{hi}}}'                                : [ [ '&', 'hi', 0, 8 ] ],
+  '{{!hi}}'                                 : [ [ '!', 'hi', 0, 7 ] ],
+  '{{! hi}}'                                : [ [ '!', 'hi', 0, 8 ] ],
+  '{{! hi }}'                               : [ [ '!', 'hi', 0, 9 ] ],
+  '{{ !hi}}'                                : [ [ '!', 'hi', 0, 8 ] ],
+  '{{ ! hi}}'                               : [ [ '!', 'hi', 0, 9 ] ],
+  '{{ ! hi }}'                              : [ [ '!', 'hi', 0, 10 ] ],
+  'a\n b'                                   : [ [ 'text', 'a\n b', 0, 4 ] ],
+  'a{{hi}}'                                 : [ [ 'text', 'a', 0, 1 ], [ 'name', 'hi', 1, 7 ] ],
+  'a {{hi}}'                                : [ [ 'text', 'a ', 0, 2 ], [ 'name', 'hi', 2, 8 ] ],
+  ' a{{hi}}'                                : [ [ 'text', ' a', 0, 2 ], [ 'name', 'hi', 2, 8 ] ],
+  ' a {{hi}}'                               : [ [ 'text', ' a ', 0, 3 ], [ 'name', 'hi', 3, 9 ] ],
+  'a{{hi}}b'                                : [ [ 'text', 'a', 0, 1 ], [ 'name', 'hi', 1, 7 ], [ 'text', 'b', 7, 8 ] ],
+  'a{{hi}} b'                               : [ [ 'text', 'a', 0, 1 ], [ 'name', 'hi', 1, 7 ], [ 'text', ' b', 7, 9 ] ],
+  'a{{hi}}b '                               : [ [ 'text', 'a', 0, 1 ], [ 'name', 'hi', 1, 7 ], [ 'text', 'b ', 7, 9 ] ],
+  'a\n{{hi}} b \n'                          : [ [ 'text', 'a\n', 0, 2 ], [ 'name', 'hi', 2, 8 ], [ 'text', ' b \n', 8, 12 ] ],
+  'a\n {{hi}} \nb'                          : [ [ 'text', 'a\n ', 0, 3 ], [ 'name', 'hi', 3, 9 ], [ 'text', ' \nb', 9, 12 ] ],
+  'a\n {{!hi}} \nb'                         : [ [ 'text', 'a\n', 0, 2 ], [ '!', 'hi', 3, 10 ], [ 'text', 'b', 12, 13 ] ],
+  'a\n{{#a}}{{/a}}\nb'                      : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 2, 8, [], 8 ], [ 'text', 'b', 15, 16 ] ],
+  'a\n {{#a}}{{/a}}\nb'                     : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [], 9 ], [ 'text', 'b', 16, 17 ] ],
+  'a\n {{#a}}{{/a}} \nb'                    : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [], 9 ], [ 'text', 'b', 17, 18 ] ],
+  'a\n{{#a}}\n{{/a}}\nb'                    : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 2, 8, [], 9 ], [ 'text', 'b', 16, 17 ] ],
+  'a\n {{#a}}\n{{/a}}\nb'                   : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [], 10 ], [ 'text', 'b', 17, 18 ] ],
+  'a\n {{#a}}\n{{/a}} \nb'                  : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [], 10 ], [ 'text', 'b', 18, 19 ] ],
+  'a\n{{#a}}\n{{/a}}\n{{#b}}\n{{/b}}\nb'    : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 2, 8, [], 9 ], [ '#', 'b', 16, 22, [], 23 ], [ 'text', 'b', 30, 31 ] ],
+  'a\n {{#a}}\n{{/a}}\n{{#b}}\n{{/b}}\nb'   : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [], 10 ], [ '#', 'b', 17, 23, [], 24 ], [ 'text', 'b', 31, 32 ] ],
+  'a\n {{#a}}\n{{/a}}\n{{#b}}\n{{/b}} \nb'  : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [], 10 ], [ '#', 'b', 17, 23, [], 24 ], [ 'text', 'b', 32, 33 ] ],
+  'a\n{{#a}}\n{{#b}}\n{{/b}}\n{{/a}}\nb'    : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 2, 8, [ [ '#', 'b', 9, 15, [], 16 ] ], 23 ], [ 'text', 'b', 30, 31 ] ],
+  'a\n {{#a}}\n{{#b}}\n{{/b}}\n{{/a}}\nb'   : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [ [ '#', 'b', 10, 16, [], 17 ] ], 24 ], [ 'text', 'b', 31, 32 ] ],
+  'a\n {{#a}}\n{{#b}}\n{{/b}}\n{{/a}} \nb'  : [ [ 'text', 'a\n', 0, 2 ], [ '#', 'a', 3, 9, [ [ '#', 'b', 10, 16, [], 17 ] ], 24 ], [ 'text', 'b', 32, 33 ] ],
+  '{{>abc}}'                                : [ [ '>', 'abc', 0, 8 ] ],
+  '{{> abc }}'                              : [ [ '>', 'abc', 0, 10 ] ],
+  '{{ > abc }}'                             : [ [ '>', 'abc', 0, 11 ] ],
+  '{{=<% %>=}}'                             : [ [ '=', '<% %>', 0, 11 ] ],
+  '{{= <% %> =}}'                           : [ [ '=', '<% %>', 0, 13 ] ],
+  '{{=<% %>=}}<%={{ }}=%>'                  : [ [ '=', '<% %>', 0, 11 ], [ '=', '{{ }}', 11, 22 ] ],
+  '{{=<% %>=}}<%hi%>'                       : [ [ '=', '<% %>', 0, 11 ], [ 'name', 'hi', 11, 17 ] ],
+  '{{#a}}{{/a}}hi{{#b}}{{/b}}\n'            : [ [ '#', 'a', 0, 6, [], 6 ], [ 'text', 'hi', 12, 14 ], [ '#', 'b', 14, 20, [], 20 ], [ 'text', '\n', 26, 27 ] ],
+  '{{a}}\n{{b}}\n\n{{#c}}\n{{/c}}\n'        : [ [ 'name', 'a', 0, 5 ], [ 'text', '\n', 5, 6 ], [ 'name', 'b', 6, 11 ], [ 'text', '\n\n', 11, 13 ], [ '#', 'c', 13, 19, [], 20 ] ],
+  '{{#foo}}\n  {{#a}}\n    {{b}}\n  {{/a}}\n{{/foo}}\n'
+                                            : [ [ '#', 'foo', 0, 8, [ [ '#', 'a', 11, 17, [ [ 'text', '    ', 18, 22 ], [ 'name', 'b', 22, 27 ], [ 'text', '\n', 27, 28 ] ], 30 ] ], 37 ] ]
+};
+
+describe('Mustache.parse', function () {
+
+  for (var template in expectations) {
+    (function (template, tokens) {
+      it('knows how to parse ' + JSON.stringify(template), function () {
+        assert.deepEqual(Mustache.parse(template), tokens);
+      });
+    })(template, expectations[template]);
+  }
+
+  describe('when there is an unclosed tag', function () {
+    it('throws an error', function () {
+      assert.throws(function () {
+        Mustache.parse('My name is {{name');
+      }, /unclosed tag at 17/i);
+    });
+  });
+
+  describe('when there is an unclosed section', function () {
+    it('throws an error', function () {
+      assert.throws(function () {
+        Mustache.parse('A list: {{#people}}{{name}}');
+      }, /unclosed section "people" at 27/i);
+    });
+  });
+
+  describe('when there is an unopened section', function () {
+    it('throws an error', function () {
+      assert.throws(function () {
+        Mustache.parse('The end of the list! {{/people}}');
+      }, /unopened section "people" at 21/i);
+    });
+  });
+
+  describe('when invalid tags are given as an argument', function () {
+    it('throws an error', function () {
+      assert.throws(function () {
+        Mustache.parse('A template <% name %>', [ '<%' ]);
+      }, /invalid tags/i);
+    });
+  });
+
+  describe('when the template contains invalid tags', function () {
+    it('throws an error', function () {
+      assert.throws(function () {
+        Mustache.parse('A template {{=<%=}}');
+      }, /invalid tags at 11/i);
+    });
+  });
+
+});

data/lib/irontask/public/components/mustache/test/render-test.js

@@ -0,0 +1,68 @@
+require('./helper');
+
+var fs = require('fs');
+var path = require('path');
+var _files = path.join(__dirname, '_files');
+
+function getContents(testName, ext) {
+  return fs.readFileSync(path.join(_files, testName + '.' + ext), 'utf8');
+}
+
+function getView(testName) {
+  var view = getContents(testName, 'js');
+  if (!view) throw new Error('Cannot find view for test "' + testName + '"');
+  return eval(view);
+}
+
+function getPartial(testName) {
+  try {
+    return getContents(testName, 'partial');
+  } catch (e) {
+    // No big deal. Not all tests need to test partial support.
+  }
+}
+
+function getTest(testName) {
+  var test = {};
+  test.view = getView(testName);
+  test.template = getContents(testName, 'mustache');
+  test.partial = getPartial(testName);
+  test.expect = getContents(testName, 'txt');
+  return test;
+}
+
+// You can put the name of a specific test to run in the TEST environment
+// variable (e.g. TEST=backslashes vows test/render-test.js)
+var testToRun = process.env.TEST;
+
+var testNames;
+if (testToRun) {
+  testNames = [testToRun];
+} else {
+  testNames = fs.readdirSync(_files).filter(function (file) {
+    return (/\.js$/).test(file);
+  }).map(function (file) {
+    return path.basename(file).replace(/\.js$/, '');
+  });
+}
+
+describe('Mustache.render', function () {
+  beforeEach(function () {
+    Mustache.clearCache();
+  });
+
+  testNames.forEach(function (testName) {
+    var test = getTest(testName);
+
+    it('knows how to render ' + testName, function () {
+      var output;
+      if (test.partial) {
+        output = Mustache.render(test.template, test.view, { partial: test.partial });
+      } else {
+        output = Mustache.render(test.template, test.view);
+      }
+
+      assert.equal(output, test.expect);
+    });
+  });
+});

data/lib/irontask/public/components/mustache/test/scanner-test.js

@@ -0,0 +1,78 @@
+require('./helper');
+var Scanner = Mustache.Scanner;
+
+describe('A new Mustache.Scanner', function () {
+  describe('for an empty string', function () {
+    it('is at the end', function () {
+      var scanner = new Scanner('');
+      assert(scanner.eos());
+    });
+  });
+
+  describe('for a non-empty string', function () {
+    var scanner;
+    beforeEach(function () {
+      scanner = new Scanner('a b c');
+    });
+
+    describe('scan', function () {
+      describe('when the RegExp matches the entire string', function () {
+        it('returns the entire string', function () {
+          var match = scanner.scan(/a b c/);
+          assert.equal(match, scanner.string);
+          assert(scanner.eos());
+        });
+      });
+
+      describe('when the RegExp matches at index 0', function () {
+        it('returns the portion of the string that matched', function () {
+          var match = scanner.scan(/a/);
+          assert.equal(match, 'a');
+          assert.equal(scanner.pos, 1);
+        });
+      });
+
+      describe('when the RegExp matches at some index other than 0', function () {
+        it('returns the empty string', function () {
+          var match = scanner.scan(/b/);
+          assert.equal(match, '');
+          assert.equal(scanner.pos, 0);
+        });
+      });
+
+      describe('when the RegExp does not match', function () {
+        it('returns the empty string', function () {
+          var match = scanner.scan(/z/);
+          assert.equal(match, '');
+          assert.equal(scanner.pos, 0);
+        });
+      });
+    }); // scan
+
+    describe('scanUntil', function () {
+      describe('when the RegExp matches at index 0', function () {
+        it('returns the empty string', function () {
+          var match = scanner.scanUntil(/a/);
+          assert.equal(match, '');
+          assert.equal(scanner.pos, 0);
+        });
+      });
+
+      describe('when the RegExp matches at some index other than 0', function () {
+        it('returns the string up to that index', function () {
+          var match = scanner.scanUntil(/b/);
+          assert.equal(match, 'a ');
+          assert.equal(scanner.pos, 2);
+        });
+      });
+
+      describe('when the RegExp does not match', function () {
+        it('returns the entire string', function () {
+          var match = scanner.scanUntil(/z/);
+          assert.equal(match, scanner.string);
+          assert(scanner.eos());
+        });
+      });
+    }); // scanUntil
+  }); // for a non-empty string
+});