style: reformat all files using prettier

spec/basic.js

@@ -18,8 +18,12 @@ describe('basic context', function() {
   });
 
   it('compiling with a basic context', function() {
-    shouldCompileTo('Goodbye\n{{cruel}}\n{{world}}!', {cruel: 'cruel', world: 'world'}, 'Goodbye\ncruel\nworld!',
-                    'It works if all the required keys are provided');
+    shouldCompileTo(
+      'Goodbye\n{{cruel}}\n{{world}}!',
+      { cruel: 'cruel', world: 'world' },
+      'Goodbye\ncruel\nworld!',
+      'It works if all the required keys are provided'
+    );
   });
 
   it('compiling with a string context', function() {
@@ -27,15 +31,26 @@ describe('basic context', function() {
   });
 
   it('compiling with an undefined context', function() {
-    shouldCompileTo('Goodbye\n{{cruel}}\n{{world.bar}}!', undefined, 'Goodbye\n\n!');
+    shouldCompileTo(
+      'Goodbye\n{{cruel}}\n{{world.bar}}!',
+      undefined,
+      'Goodbye\n\n!'
+    );
 
-    shouldCompileTo('{{#unless foo}}Goodbye{{../test}}{{test2}}{{/unless}}', undefined, 'Goodbye');
+    shouldCompileTo(
+      '{{#unless foo}}Goodbye{{../test}}{{test2}}{{/unless}}',
+      undefined,
+      'Goodbye'
+    );
   });
 
   it('comments', function() {
-    shouldCompileTo('{{! Goodbye}}Goodbye\n{{cruel}}\n{{world}}!',
-      {cruel: 'cruel', world: 'world'}, 'Goodbye\ncruel\nworld!',
-      'comments are ignored');
+    shouldCompileTo(
+      '{{! Goodbye}}Goodbye\n{{cruel}}\n{{world}}!',
+      { cruel: 'cruel', world: 'world' },
+      'Goodbye\ncruel\nworld!',
+      'comments are ignored'
+    );
 
     shouldCompileTo('    {{~! comment ~}}      blah', {}, 'blah');
     shouldCompileTo('    {{~!-- long-comment --~}}      blah', {}, 'blah');
@@ -47,237 +62,506 @@ describe('basic context', function() {
 
   it('boolean', function() {
     var string = '{{#goodbye}}GOODBYE {{/goodbye}}cruel {{world}}!';
-    shouldCompileTo(string, {goodbye: true, world: 'world'}, 'GOODBYE cruel world!',
-                    'booleans show the contents when true');
+    shouldCompileTo(
+      string,
+      { goodbye: true, world: 'world' },
+      'GOODBYE cruel world!',
+      'booleans show the contents when true'
+    );
 
-    shouldCompileTo(string, {goodbye: false, world: 'world'}, 'cruel world!',
-                    'booleans do not show the contents when false');
+    shouldCompileTo(
+      string,
+      { goodbye: false, world: 'world' },
+      'cruel world!',
+      'booleans do not show the contents when false'
+    );
   });
 
   it('zeros', function() {
-    shouldCompileTo('num1: {{num1}}, num2: {{num2}}', {num1: 42, num2: 0},
-        'num1: 42, num2: 0');
+    shouldCompileTo(
+      'num1: {{num1}}, num2: {{num2}}',
+      { num1: 42, num2: 0 },
+      'num1: 42, num2: 0'
+    );
     shouldCompileTo('num: {{.}}', 0, 'num: 0');
-    shouldCompileTo('num: {{num1/num2}}', {num1: {num2: 0}}, 'num: 0');
+    shouldCompileTo('num: {{num1/num2}}', { num1: { num2: 0 } }, 'num: 0');
   });
   it('false', function() {
     /* eslint-disable no-new-wrappers */
-    shouldCompileTo('val1: {{val1}}, val2: {{val2}}', {val1: false, val2: new Boolean(false)}, 'val1: false, val2: false');
+    shouldCompileTo(
+      'val1: {{val1}}, val2: {{val2}}',
+      { val1: false, val2: new Boolean(false) },
+      'val1: false, val2: false'
+    );
     shouldCompileTo('val: {{.}}', false, 'val: false');
-    shouldCompileTo('val: {{val1/val2}}', {val1: {val2: false}}, 'val: false');
+    shouldCompileTo(
+      'val: {{val1/val2}}',
+      { val1: { val2: false } },
+      'val: false'
+    );
 
-    shouldCompileTo('val1: {{{val1}}}, val2: {{{val2}}}', {val1: false, val2: new Boolean(false)}, 'val1: false, val2: false');
-    shouldCompileTo('val: {{{val1/val2}}}', {val1: {val2: false}}, 'val: false');
+    shouldCompileTo(
+      'val1: {{{val1}}}, val2: {{{val2}}}',
+      { val1: false, val2: new Boolean(false) },
+      'val1: false, val2: false'
+    );
+    shouldCompileTo(
+      'val: {{{val1/val2}}}',
+      { val1: { val2: false } },
+      'val: false'
+    );
     /* eslint-enable */
   });
 
   it('should handle undefined and null', function() {
-    shouldCompileTo('{{awesome undefined null}}',
-        {
-          awesome: function(_undefined, _null, options) {
-            return (_undefined === undefined) + ' ' + (_null === null) + ' ' + (typeof options);
-          }
-        },
-        'true true object');
-    shouldCompileTo('{{undefined}}',
-        {
-          'undefined': function() {
-            return 'undefined!';
-          }
-        },
-        'undefined!');
-    shouldCompileTo('{{null}}',
-        {
-          'null': function() {
-            return 'null!';
-          }
-        },
-        'null!');
+    shouldCompileTo(
+      '{{awesome undefined null}}',
+      {
+        awesome: function(_undefined, _null, options) {
+          return (
+            (_undefined === undefined) +
+            ' ' +
+            (_null === null) +
+            ' ' +
+            typeof options
+          );
+        }
+      },
+      'true true object'
+    );
+    shouldCompileTo(
+      '{{undefined}}',
+      {
+        undefined: function() {
+          return 'undefined!';
+        }
+      },
+      'undefined!'
+    );
+    shouldCompileTo(
+      '{{null}}',
+      {
+        null: function() {
+          return 'null!';
+        }
+      },
+      'null!'
+    );
   });
 
   it('newlines', function() {
-      shouldCompileTo("Alan's\nTest", {}, "Alan's\nTest");
-      shouldCompileTo("Alan's\rTest", {}, "Alan's\rTest");
+    shouldCompileTo("Alan's\nTest", {}, "Alan's\nTest");
+    shouldCompileTo("Alan's\rTest", {}, "Alan's\rTest");
   });
 
   it('escaping text', function() {
-    shouldCompileTo("Awesome's", {}, "Awesome's", "text is escaped so that it doesn't get caught on single quotes");
-    shouldCompileTo('Awesome\\', {}, 'Awesome\\', "text is escaped so that the closing quote can't be ignored");
-    shouldCompileTo('Awesome\\\\ foo', {}, 'Awesome\\\\ foo', "text is escaped so that it doesn't mess up backslashes");
-    shouldCompileTo('Awesome {{foo}}', {foo: '\\'}, 'Awesome \\', "text is escaped so that it doesn't mess up backslashes");
-    shouldCompileTo(" ' ' ", {}, " ' ' ", 'double quotes never produce invalid javascript');
+    shouldCompileTo(
+      "Awesome's",
+      {},
+      "Awesome's",
+      "text is escaped so that it doesn't get caught on single quotes"
+    );
+    shouldCompileTo(
+      'Awesome\\',
+      {},
+      'Awesome\\',
+      "text is escaped so that the closing quote can't be ignored"
+    );
+    shouldCompileTo(
+      'Awesome\\\\ foo',
+      {},
+      'Awesome\\\\ foo',
+      "text is escaped so that it doesn't mess up backslashes"
+    );
+    shouldCompileTo(
+      'Awesome {{foo}}',
+      { foo: '\\' },
+      'Awesome \\',
+      "text is escaped so that it doesn't mess up backslashes"
+    );
+    shouldCompileTo(
+      " ' ' ",
+      {},
+      " ' ' ",
+      'double quotes never produce invalid javascript'
+    );
   });
 
   it('escaping expressions', function() {
-   shouldCompileTo('{{{awesome}}}', {awesome: '&\'\\<>'}, '&\'\\<>',
-          "expressions with 3 handlebars aren't escaped");
+    shouldCompileTo(
+      '{{{awesome}}}',
+      { awesome: "&'\\<>" },
+      "&'\\<>",
+      "expressions with 3 handlebars aren't escaped"
+    );
 
-   shouldCompileTo('{{&awesome}}', {awesome: '&\'\\<>'}, '&\'\\<>',
-          "expressions with {{& handlebars aren't escaped");
+    shouldCompileTo(
+      '{{&awesome}}',
+      { awesome: "&'\\<>" },
+      "&'\\<>",
+      "expressions with {{& handlebars aren't escaped"
+    );
 
-   shouldCompileTo('{{awesome}}', {awesome: "&\"'`\\<>"}, '&amp;&quot;&#x27;&#x60;\\&lt;&gt;',
-          'by default expressions should be escaped');
+    shouldCompileTo(
+      '{{awesome}}',
+      { awesome: '&"\'`\\<>' },
+      '&amp;&quot;&#x27;&#x60;\\&lt;&gt;',
+      'by default expressions should be escaped'
+    );
 
-   shouldCompileTo('{{awesome}}', {awesome: 'Escaped, <b> looks like: &lt;b&gt;'}, 'Escaped, &lt;b&gt; looks like: &amp;lt;b&amp;gt;',
-          'escaping should properly handle amperstands');
+    shouldCompileTo(
+      '{{awesome}}',
+      { awesome: 'Escaped, <b> looks like: &lt;b&gt;' },
+      'Escaped, &lt;b&gt; looks like: &amp;lt;b&amp;gt;',
+      'escaping should properly handle amperstands'
+    );
   });
 
   it("functions returning safestrings shouldn't be escaped", function() {
-    var hash = {awesome: function() { return new Handlebars.SafeString('&\'\\<>'); }};
-    shouldCompileTo('{{awesome}}', hash, '&\'\\<>',
-        "functions returning safestrings aren't escaped");
+    var hash = {
+      awesome: function() {
+        return new Handlebars.SafeString("&'\\<>");
+      }
+    };
+    shouldCompileTo(
+      '{{awesome}}',
+      hash,
+      "&'\\<>",
+      "functions returning safestrings aren't escaped"
+    );
   });
 
   it('functions', function() {
-    shouldCompileTo('{{awesome}}', {awesome: function() { return 'Awesome'; }}, 'Awesome',
-                    'functions are called and render their output');
-    shouldCompileTo('{{awesome}}', {awesome: function() { return this.more; }, more: 'More awesome'}, 'More awesome',
-                    'functions are bound to the context');
+    shouldCompileTo(
+      '{{awesome}}',
+      {
+        awesome: function() {
+          return 'Awesome';
+        }
+      },
+      'Awesome',
+      'functions are called and render their output'
+    );
+    shouldCompileTo(
+      '{{awesome}}',
+      {
+        awesome: function() {
+          return this.more;
+        },
+        more: 'More awesome'
+      },
+      'More awesome',
+      'functions are bound to the context'
+    );
   });
 
   it('functions with context argument', function() {
-    shouldCompileTo('{{awesome frank}}',
-        {awesome: function(context) { return context; },
-          frank: 'Frank'},
-        'Frank', 'functions are called with context arguments');
+    shouldCompileTo(
+      '{{awesome frank}}',
+      {
+        awesome: function(context) {
+          return context;
+        },
+        frank: 'Frank'
+      },
+      'Frank',
+      'functions are called with context arguments'
+    );
   });
   it('pathed functions with context argument', function() {
-    shouldCompileTo('{{bar.awesome frank}}',
-        {bar: {awesome: function(context) { return context; }},
-          frank: 'Frank'},
-        'Frank', 'functions are called with context arguments');
+    shouldCompileTo(
+      '{{bar.awesome frank}}',
+      {
+        bar: {
+          awesome: function(context) {
+            return context;
+          }
+        },
+        frank: 'Frank'
+      },
+      'Frank',
+      'functions are called with context arguments'
+    );
   });
   it('depthed functions with context argument', function() {
-    shouldCompileTo('{{#with frank}}{{../awesome .}}{{/with}}',
-        {awesome: function(context) { return context; },
-          frank: 'Frank'},
-        'Frank', 'functions are called with context arguments');
+    shouldCompileTo(
+      '{{#with frank}}{{../awesome .}}{{/with}}',
+      {
+        awesome: function(context) {
+          return context;
+        },
+        frank: 'Frank'
+      },
+      'Frank',
+      'functions are called with context arguments'
+    );
   });
 
   it('block functions with context argument', function() {
-    shouldCompileTo('{{#awesome 1}}inner {{.}}{{/awesome}}',
-        {awesome: function(context, options) { return options.fn(context); }},
-        'inner 1', 'block functions are called with context and options');
+    shouldCompileTo(
+      '{{#awesome 1}}inner {{.}}{{/awesome}}',
+      {
+        awesome: function(context, options) {
+          return options.fn(context);
+        }
+      },
+      'inner 1',
+      'block functions are called with context and options'
+    );
   });
 
   it('depthed block functions with context argument', function() {
-    shouldCompileTo('{{#with value}}{{#../awesome 1}}inner {{.}}{{/../awesome}}{{/with}}',
-        {value: true, awesome: function(context, options) { return options.fn(context); }},
-        'inner 1', 'block functions are called with context and options');
+    shouldCompileTo(
+      '{{#with value}}{{#../awesome 1}}inner {{.}}{{/../awesome}}{{/with}}',
+      {
+        value: true,
+        awesome: function(context, options) {
+          return options.fn(context);
+        }
+      },
+      'inner 1',
+      'block functions are called with context and options'
+    );
   });
 
   it('block functions without context argument', function() {
-    shouldCompileTo('{{#awesome}}inner{{/awesome}}',
-        {awesome: function(options) { return options.fn(this); }},
-        'inner', 'block functions are called with options');
+    shouldCompileTo(
+      '{{#awesome}}inner{{/awesome}}',
+      {
+        awesome: function(options) {
+          return options.fn(this);
+        }
+      },
+      'inner',
+      'block functions are called with options'
+    );
   });
   it('pathed block functions without context argument', function() {
-    shouldCompileTo('{{#foo.awesome}}inner{{/foo.awesome}}',
-        {foo: {awesome: function() { return this; }}},
-        'inner', 'block functions are called with options');
+    shouldCompileTo(
+      '{{#foo.awesome}}inner{{/foo.awesome}}',
+      {
+        foo: {
+          awesome: function() {
+            return this;
+          }
+        }
+      },
+      'inner',
+      'block functions are called with options'
+    );
   });
   it('depthed block functions without context argument', function() {
-    shouldCompileTo('{{#with value}}{{#../awesome}}inner{{/../awesome}}{{/with}}',
-        {value: true, awesome: function() { return this; }},
-        'inner', 'block functions are called with options');
+    shouldCompileTo(
+      '{{#with value}}{{#../awesome}}inner{{/../awesome}}{{/with}}',
+      {
+        value: true,
+        awesome: function() {
+          return this;
+        }
+      },
+      'inner',
+      'block functions are called with options'
+    );
   });
 
-
   it('paths with hyphens', function() {
-    shouldCompileTo('{{foo-bar}}', {'foo-bar': 'baz'}, 'baz', 'Paths can contain hyphens (-)');
-    shouldCompileTo('{{foo.foo-bar}}', {foo: {'foo-bar': 'baz'}}, 'baz', 'Paths can contain hyphens (-)');
-    shouldCompileTo('{{foo/foo-bar}}', {foo: {'foo-bar': 'baz'}}, 'baz', 'Paths can contain hyphens (-)');
+    shouldCompileTo(
+      '{{foo-bar}}',
+      { 'foo-bar': 'baz' },
+      'baz',
+      'Paths can contain hyphens (-)'
+    );
+    shouldCompileTo(
+      '{{foo.foo-bar}}',
+      { foo: { 'foo-bar': 'baz' } },
+      'baz',
+      'Paths can contain hyphens (-)'
+    );
+    shouldCompileTo(
+      '{{foo/foo-bar}}',
+      { foo: { 'foo-bar': 'baz' } },
+      'baz',
+      'Paths can contain hyphens (-)'
+    );
   });
 
   it('nested paths', function() {
-    shouldCompileTo('Goodbye {{alan/expression}} world!', {alan: {expression: 'beautiful'}},
-                    'Goodbye beautiful world!', 'Nested paths access nested objects');
+    shouldCompileTo(
+      'Goodbye {{alan/expression}} world!',
+      { alan: { expression: 'beautiful' } },
+      'Goodbye beautiful world!',
+      'Nested paths access nested objects'
+    );
   });
 
   it('nested paths with empty string value', function() {
-    shouldCompileTo('Goodbye {{alan/expression}} world!', {alan: {expression: ''}},
-                    'Goodbye  world!', 'Nested paths access nested objects with empty string');
+    shouldCompileTo(
+      'Goodbye {{alan/expression}} world!',
+      { alan: { expression: '' } },
+      'Goodbye  world!',
+      'Nested paths access nested objects with empty string'
+    );
   });
 
   it('literal paths', function() {
-    shouldCompileTo('Goodbye {{[@alan]/expression}} world!', {'@alan': {expression: 'beautiful'}},
-        'Goodbye beautiful world!', 'Literal paths can be used');
-    shouldCompileTo('Goodbye {{[foo bar]/expression}} world!', {'foo bar': {expression: 'beautiful'}},
-        'Goodbye beautiful world!', 'Literal paths can be used');
+    shouldCompileTo(
+      'Goodbye {{[@alan]/expression}} world!',
+      { '@alan': { expression: 'beautiful' } },
+      'Goodbye beautiful world!',
+      'Literal paths can be used'
+    );
+    shouldCompileTo(
+      'Goodbye {{[foo bar]/expression}} world!',
+      { 'foo bar': { expression: 'beautiful' } },
+      'Goodbye beautiful world!',
+      'Literal paths can be used'
+    );
   });
 
   it('literal references', function() {
-    shouldCompileTo('Goodbye {{[foo bar]}} world!', {'foo bar': 'beautiful'}, 'Goodbye beautiful world!');
-    shouldCompileTo('Goodbye {{"foo bar"}} world!', {'foo bar': 'beautiful'}, 'Goodbye beautiful world!');
-    shouldCompileTo("Goodbye {{'foo bar'}} world!", {'foo bar': 'beautiful'}, 'Goodbye beautiful world!');
-    shouldCompileTo('Goodbye {{"foo[bar"}} world!', {'foo[bar': 'beautiful'}, 'Goodbye beautiful world!');
-    shouldCompileTo('Goodbye {{"foo\'bar"}} world!', {"foo'bar": 'beautiful'}, 'Goodbye beautiful world!');
-    shouldCompileTo("Goodbye {{'foo\"bar'}} world!", {'foo"bar': 'beautiful'}, 'Goodbye beautiful world!');
+    shouldCompileTo(
+      'Goodbye {{[foo bar]}} world!',
+      { 'foo bar': 'beautiful' },
+      'Goodbye beautiful world!'
+    );
+    shouldCompileTo(
+      'Goodbye {{"foo bar"}} world!',
+      { 'foo bar': 'beautiful' },
+      'Goodbye beautiful world!'
+    );
+    shouldCompileTo(
+      "Goodbye {{'foo bar'}} world!",
+      { 'foo bar': 'beautiful' },
+      'Goodbye beautiful world!'
+    );
+    shouldCompileTo(
+      'Goodbye {{"foo[bar"}} world!',
+      { 'foo[bar': 'beautiful' },
+      'Goodbye beautiful world!'
+    );
+    shouldCompileTo(
+      'Goodbye {{"foo\'bar"}} world!',
+      { "foo'bar": 'beautiful' },
+      'Goodbye beautiful world!'
+    );
+    shouldCompileTo(
+      "Goodbye {{'foo\"bar'}} world!",
+      { 'foo"bar': 'beautiful' },
+      'Goodbye beautiful world!'
+    );
   });
 
   it("that current context path ({{.}}) doesn't hit helpers", function() {
-    shouldCompileTo('test: {{.}}', [null, {helper: 'awesome'}], 'test: ');
+    shouldCompileTo('test: {{.}}', [null, { helper: 'awesome' }], 'test: ');
   });
 
   it('complex but empty paths', function() {
-    shouldCompileTo('{{person/name}}', {person: {name: null}}, '');
-    shouldCompileTo('{{person/name}}', {person: {}}, '');
+    shouldCompileTo('{{person/name}}', { person: { name: null } }, '');
+    shouldCompileTo('{{person/name}}', { person: {} }, '');
   });
 
   it('this keyword in paths', function() {
     var string = '{{#goodbyes}}{{this}}{{/goodbyes}}';
-    var hash = {goodbyes: ['goodbye', 'Goodbye', 'GOODBYE']};
-    shouldCompileTo(string, hash, 'goodbyeGoodbyeGOODBYE',
-      'This keyword in paths evaluates to current context');
+    var hash = { goodbyes: ['goodbye', 'Goodbye', 'GOODBYE'] };
+    shouldCompileTo(
+      string,
+      hash,
+      'goodbyeGoodbyeGOODBYE',
+      'This keyword in paths evaluates to current context'
+    );
 
     string = '{{#hellos}}{{this/text}}{{/hellos}}';
-    hash = {hellos: [{text: 'hello'}, {text: 'Hello'}, {text: 'HELLO'}]};
-    shouldCompileTo(string, hash, 'helloHelloHELLO', 'This keyword evaluates in more complex paths');
+    hash = {
+      hellos: [{ text: 'hello' }, { text: 'Hello' }, { text: 'HELLO' }]
+    };
+    shouldCompileTo(
+      string,
+      hash,
+      'helloHelloHELLO',
+      'This keyword evaluates in more complex paths'
+    );
   });
 
   it('this keyword nested inside path', function() {
-    shouldThrow(function() {
-      CompilerContext.compile('{{#hellos}}{{text/this/foo}}{{/hellos}}');
-    }, Error, 'Invalid path: text/this - 1:13');
+    shouldThrow(
+      function() {
+        CompilerContext.compile('{{#hellos}}{{text/this/foo}}{{/hellos}}');
+      },
+      Error,
+      'Invalid path: text/this - 1:13'
+    );
 
-    shouldCompileTo('{{[this]}}', {'this': 'bar'}, 'bar');
-    shouldCompileTo('{{text/[this]}}', {text: {'this': 'bar'}}, 'bar');
+    shouldCompileTo('{{[this]}}', { this: 'bar' }, 'bar');
+    shouldCompileTo('{{text/[this]}}', { text: { this: 'bar' } }, 'bar');
   });
 
   it('this keyword in helpers', function() {
-    var helpers = {foo: function(value) {
+    var helpers = {
+      foo: function(value) {
         return 'bar ' + value;
-    }};
+      }
+    };
     var string = '{{#goodbyes}}{{foo this}}{{/goodbyes}}';
-    var hash = {goodbyes: ['goodbye', 'Goodbye', 'GOODBYE']};
-    shouldCompileTo(string, [hash, helpers], 'bar goodbyebar Goodbyebar GOODBYE',
-      'This keyword in paths evaluates to current context');
+    var hash = { goodbyes: ['goodbye', 'Goodbye', 'GOODBYE'] };
+    shouldCompileTo(
+      string,
+      [hash, helpers],
+      'bar goodbyebar Goodbyebar GOODBYE',
+      'This keyword in paths evaluates to current context'
+    );
 
     string = '{{#hellos}}{{foo this/text}}{{/hellos}}';
-    hash = {hellos: [{text: 'hello'}, {text: 'Hello'}, {text: 'HELLO'}]};
-    shouldCompileTo(string, [hash, helpers], 'bar hellobar Hellobar HELLO', 'This keyword evaluates in more complex paths');
+    hash = {
+      hellos: [{ text: 'hello' }, { text: 'Hello' }, { text: 'HELLO' }]
+    };
+    shouldCompileTo(
+      string,
+      [hash, helpers],
+      'bar hellobar Hellobar HELLO',
+      'This keyword evaluates in more complex paths'
+    );
   });
 
   it('this keyword nested inside helpers param', function() {
     var string = '{{#hellos}}{{foo text/this/foo}}{{/hellos}}';
-    shouldThrow(function() {
-      CompilerContext.compile(string);
-    }, Error, 'Invalid path: text/this - 1:17');
+    shouldThrow(
+      function() {
+        CompilerContext.compile(string);
+      },
+      Error,
+      'Invalid path: text/this - 1:17'
+    );
 
     shouldCompileTo(
-        '{{foo [this]}}',
-        {foo: function(value) { return value; }, 'this': 'bar'},
-        'bar');
+      '{{foo [this]}}',
+      {
+        foo: function(value) {
+          return value;
+        },
+        this: 'bar'
+      },
+      'bar'
+    );
     shouldCompileTo(
-        '{{foo text/[this]}}',
-        {foo: function(value) { return value; }, text: {'this': 'bar'}},
-        'bar');
+      '{{foo text/[this]}}',
+      {
+        foo: function(value) {
+          return value;
+        },
+        text: { this: 'bar' }
+      },
+      'bar'
+    );
   });
 
   it('pass string literals', function() {
     shouldCompileTo('{{"foo"}}', {}, '');
     shouldCompileTo('{{"foo"}}', { foo: 'bar' }, 'bar');
-    shouldCompileTo('{{#"foo"}}{{.}}{{/"foo"}}', { foo: ['bar', 'baz'] }, 'barbaz');
+    shouldCompileTo(
+      '{{#"foo"}}{{.}}{{/"foo"}}',
+      { foo: ['bar', 'baz'] },
+      'barbaz'
+    );
   });
 
   it('pass number literals', function() {
@@ -285,13 +569,21 @@ describe('basic context', function() {
     shouldCompileTo('{{12}}', { '12': 'bar' }, 'bar');
     shouldCompileTo('{{12.34}}', {}, '');
     shouldCompileTo('{{12.34}}', { '12.34': 'bar' }, 'bar');
-    shouldCompileTo('{{12.34 1}}', { '12.34': function(arg) { return 'bar' + arg; } }, 'bar1');
+    shouldCompileTo(
+      '{{12.34 1}}',
+      {
+        '12.34': function(arg) {
+          return 'bar' + arg;
+        }
+      },
+      'bar1'
+    );
   });
 
   it('pass boolean literals', function() {
     shouldCompileTo('{{true}}', {}, '');
     shouldCompileTo('{{true}}', { '': 'foo' }, '');
-    shouldCompileTo('{{false}}', { 'false': 'foo' }, 'foo');
+    shouldCompileTo('{{false}}', { false: 'foo' }, 'foo');
   });
 
   it('should handle literals in subexpression', function() {
@@ -300,6 +592,17 @@ describe('basic context', function() {
         return arg;
       }
     };
-    shouldCompileTo('{{foo (false)}}', [{ 'false': function() { return 'bar'; } }, helpers], 'bar');
+    shouldCompileTo(
+      '{{foo (false)}}',
+      [
+        {
+          false: function() {
+            return 'bar';
+          }
+        },
+        helpers
+      ],
+      'bar'
+    );
   });
 });