From b04b813f025913fb13a91419062a4279bab80335 Mon Sep 17 00:00:00 2001
From: Brad Dunbar <dunbarb2@gmail.com>
Date: Tue, 3 Apr 2012 10:57:39 -0700
Subject: [PATCH 1/3] Add varname to _.templateSettings.

* Leave out the with statement when using varname.
* Rename source to compiled.
* Comments, comments, comments.
---
 index.html      | 23 +++++++++++++++++-----
 test/utility.js | 11 ++++++++++-
 underscore.js   | 51 +++++++++++++++++++++++++++++++------------------
 3 files changed, 60 insertions(+), 25 deletions(-)
diff --git a/index.html b/index.html
index f38ffa8ab..1872377d9 100644
--- a/index.html
+++ b/index.html
@@ -3,7 +3,7 @@
 <head>
   <meta http-equiv="content-type" content="text/html;charset=UTF-8" />
   <meta http-equiv="X-UA-Compatible" content="chrome=1">
-  <link rel="shortcut icon" href="favicon.ico" type="image/x-icon" />  
+  <link rel="shortcut icon" href="favicon.ico" type="image/x-icon" />
   <title>Underscore.js</title>
   <style>
     body {
@@ -1348,6 +1348,7 @@ _.result(object, 'stuff');
         object as the second parameter to <b>template</b> in order to render
         immediately instead of returning a template function.
       </p>
+
       <pre>
 var compiled = _.template("hello: &lt;%= name %&gt;");
 compiled({name : 'moe'});
@@ -1393,16 +1394,28 @@ var template = _.template("Hello {{ name }}!");
 template({name : "Mustache"});
 =&gt; "Hello Mustache!"</pre>
 
+      <p>
+        By default, <b>template</b> places the values from your data in the local scope
+        via the <tt>with</tt> statement.  However, you can specify a single variable name
+        with the <b>varname</b> setting.
+      </p>
+
+      <pre>
+_.templateSettings.varname = 'data';
+var template = _.template("<%= data.hasWith %>");
+template({hasWith: 'no'});
+=&gt; "no"</pre>
+
       <p>
         Precompiling your templates can be a big help when debugging errors you can't
         reproduce.  This is because precompiled templates can provide line numbers and
         a stack trace, something that is not possible when compiling templates on the client.
-        <b>template</b> provides the <b>source</b> property on the compiled template
+        <b>template</b> provides the <b>compiled</b> property on the compiled template
         function for easy precompilation.
       </p>
 
       <pre>&lt;script&gt;
-  JST.project = <%= _.template(jstText).source %>;
+  JST.project = <%= _.template(jstText).compiled %>;
 &lt;/script&gt;</pre>
 
 
@@ -1570,8 +1583,8 @@ _([1, 2, 3]).value();
         <b class="header">1.2.4</b> &mdash; <small><i>Jan. 4, 2012</i></small><br />
         <ul>
           <li>
-            You now can (and probably should, as it's simpler) 
-            write <tt>_.chain(list)</tt> 
+            You now can (and probably should, as it's simpler)
+            write <tt>_.chain(list)</tt>
             instead of <tt>_(list).chain()</tt>.
           </li>
           <li>
diff --git a/test/utility.js b/test/utility.js
index da374b59d..dc5461b8d 100644
--- a/test/utility.js
+++ b/test/utility.js
@@ -1,9 +1,13 @@
 $(document).ready(function() {
 
-  var templateSettings = _.templateSettings;
+  var templateSettings;
 
   module("Utility", {
 
+    setup: function() {
+      templateSettings = _.clone(_.templateSettings);
+    },
+
     teardown: function() {
       _.templateSettings = templateSettings;
     }
@@ -174,4 +178,9 @@ $(document).ready(function() {
     strictEqual(_.result(null, 'x'), null);
   });
 
+  test('_.templateSettings.varname', function() {
+    _.templateSettings.varname = 'data';
+    strictEqual(_.template('<%=data.x%>')({x: 'x'}), 'x');
+  });
+
 });
diff --git a/underscore.js b/underscore.js
index 3b6e4b990..7c2f3e96a 100644
--- a/underscore.js
+++ b/underscore.js
@@ -951,30 +951,43 @@
   // JavaScript micro-templating, similar to John Resig's implementation.
   // Underscore templating handles arbitrary delimiters, preserves whitespace,
   // and correctly escapes quotes within interpolated code.
-  _.template = function(str, data) {
+  _.template = function(source, data) {
     var settings  = _.templateSettings;
-    var source = 'var __p=[],print=function(){__p.push.apply(__p,arguments);};' +
-      'with(obj||{}){__p.push(\'' +
-      str
-        .replace(escaper, function(match) {
-          return '\\' + escapes[match];
-        })
-        .replace(settings.escape || noMatch, function(match, code) {
-          return "',\n_.escape(" + unescape(code) + "),\n'";
-        })
-        .replace(settings.interpolate || noMatch, function(match, code) {
-          return "',\n" + unescape(code) + ",\n'";
-        })
-        .replace(settings.evaluate || noMatch, function(match, code) {
-          return "');\n" + unescape(code) + "\n;__p.push('";
-        })
-        + "');\n}\nreturn __p.join('');";
-    var render = new Function('obj', '_', source);
+    var varname = settings.varname || 'obj';
+
+    // Compile the template source, taking care to escape characters that
+    // cannot be included in a string literal and then unescape them in code
+    // blocks.
+    var compiled = "__p.push('" + source
+      .replace(escaper, function(match) {
+        return '\\' + escapes[match];
+      })
+      .replace(settings.escape || noMatch, function(match, code) {
+        return "',\n_.escape(" + unescape(code) + "),\n'";
+      })
+      .replace(settings.interpolate || noMatch, function(match, code) {
+        return "',\n" + unescape(code) + ",\n'";
+      })
+      .replace(settings.evaluate || noMatch, function(match, code) {
+        return "');\n" + unescape(code) + "\n;__p.push('";
+      }) + "');\n";
+
+    // If no varname is specified, place data values in local scope.
+    if (!settings.varname) compiled = 'with(obj||{}){\n' + compiled + '}\n';
+
+    compiled = 'var __p=[],print=function(){__p.push.apply(__p,arguments);};\n' +
+      compiled + "return __p.join('');\n";
+
+    var render = new Function(varname, '_', compiled);
     if (data) return render(data, _);
     var template = function(data) {
       return render.call(this, data, _);
     };
-    template.source = 'function(obj){\n' + source + '\n}';
+
+    // Provide the compiled function source as a convenience for build time
+    // precompilation.
+    template.compiled = 'function(' + varname + '){\n' + compiled + '\n}';
+
     return template;
   };
 

From 89c50e1a9598296f795fd70dcecfebc19ae81ec2 Mon Sep 17 00:00:00 2001
From: Brad Dunbar <dunbarb2@gmail.com>
Date: Tue, 3 Apr 2012 17:38:39 -0700
Subject: [PATCH 2/3] Allow _.templateSettings to be overriden.

---
 test/utility.js |  5 ++++-
 underscore.js   | 10 +++++-----
 2 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/test/utility.js b/test/utility.js
index dc5461b8d..03577800a 100644
--- a/test/utility.js
+++ b/test/utility.js
@@ -179,8 +179,11 @@ $(document).ready(function() {
   });
 
   test('_.templateSettings.varname', function() {
+    var s = '<%=data.x%>';
+    var data = {x: 'x'};
+    strictEqual(_.template(s, data, {varname: 'data'}), 'x')
     _.templateSettings.varname = 'data';
-    strictEqual(_.template('<%=data.x%>')({x: 'x'}), 'x');
+    strictEqual(_.template(s)(data), 'x')
   });
 
 });
diff --git a/underscore.js b/underscore.js
index 7c2f3e96a..30ba01ed5 100644
--- a/underscore.js
+++ b/underscore.js
@@ -951,9 +951,8 @@
   // JavaScript micro-templating, similar to John Resig's implementation.
   // Underscore templating handles arbitrary delimiters, preserves whitespace,
   // and correctly escapes quotes within interpolated code.
-  _.template = function(source, data) {
-    var settings  = _.templateSettings;
-    var varname = settings.varname || 'obj';
+  _.template = function(source, data, settings) {
+    settings = _.extend(_.templateSettings, settings);
 
     // Compile the template source, taking care to escape characters that
     // cannot be included in a string literal and then unescape them in code
@@ -978,7 +977,7 @@
     compiled = 'var __p=[],print=function(){__p.push.apply(__p,arguments);};\n' +
       compiled + "return __p.join('');\n";
 
-    var render = new Function(varname, '_', compiled);
+    var render = new Function(settings.varname || 'obj', '_', compiled);
     if (data) return render(data, _);
     var template = function(data) {
       return render.call(this, data, _);
@@ -986,7 +985,8 @@
 
     // Provide the compiled function source as a convenience for build time
     // precompilation.
-    template.compiled = 'function(' + varname + '){\n' + compiled + '\n}';
+    template.compiled = 'function(' + (settings.varname || 'obj') + '){\n' +
+      compiled + '\n}';
 
     return template;
   };

From f50690f67e6f333f7c213b7f646a30ddeba07348 Mon Sep 17 00:00:00 2001
From: Brad Dunbar <dunbarb2@gmail.com>
Date: Wed, 4 Apr 2012 08:15:49 -0700
Subject: [PATCH 3/3] Tweak variable names.  Update docs.

* Restore template.source.
* Use variable instead of varname.
* Use text for template input.
* Include settings in documentation.
---
 index.html      | 19 +++++++++----------
 test/utility.js |  6 +++---
 underscore.js   | 18 +++++++++---------
 3 files changed, 21 insertions(+), 22 deletions(-)

diff --git a/index.html b/index.html
index 1872377d9..ef0018e75 100644
--- a/index.html
+++ b/index.html
@@ -1335,7 +1335,7 @@ _.result(object, 'stuff');
 =&gt; "nonsense"</pre>
 
       <p id="template">
-        <b class="header">template</b><code>_.template(templateString, [context])</code>
+        <b class="header">template</b><code>_.template(templateString, [data], [settings])</code>
         <br />
         Compiles JavaScript templates into functions that can be evaluated
         for rendering. Useful for rendering complicated bits of HTML from JSON
@@ -1343,10 +1343,11 @@ _.result(object, 'stuff');
         <tt>&lt;%= &hellip; %&gt;</tt>, as well as execute arbitrary JavaScript code, with
         <tt>&lt;% &hellip; %&gt;</tt>. If you wish to interpolate a value, and have
         it be HTML-escaped, use <tt>&lt;%- &hellip; %&gt;</tt> When you evaluate a template function, pass in a
-        <b>context</b> object that has properties corresponding to the template's free
-        variables. If you're writing a one-off, you can pass the <b>context</b>
+        <b>data</b> object that has properties corresponding to the template's free
+        variables. If you're writing a one-off, you can pass the <b>data</b>
         object as the second parameter to <b>template</b> in order to render
-        immediately instead of returning a template function.
+        immediately instead of returning a template function.  The <b>settings</b> argument
+        should be a hash containing any <tt>_.templateSettings</tt> that should be overriden.
       </p>
 
       <pre>
@@ -1397,25 +1398,23 @@ template({name : "Mustache"});
       <p>
         By default, <b>template</b> places the values from your data in the local scope
         via the <tt>with</tt> statement.  However, you can specify a single variable name
-        with the <b>varname</b> setting.
+        with the <b>variable</b> setting.
       </p>
 
       <pre>
-_.templateSettings.varname = 'data';
-var template = _.template("<%= data.hasWith %>");
-template({hasWith: 'no'});
+_.template("<%= data.hasWith %>", {hasWith: 'no'}, {variable: 'data'});
 =&gt; "no"</pre>
 
       <p>
         Precompiling your templates can be a big help when debugging errors you can't
         reproduce.  This is because precompiled templates can provide line numbers and
         a stack trace, something that is not possible when compiling templates on the client.
-        <b>template</b> provides the <b>compiled</b> property on the compiled template
+        <b>template</b> provides the <b>source</b> property on the compiled template
         function for easy precompilation.
       </p>
 
       <pre>&lt;script&gt;
-  JST.project = <%= _.template(jstText).compiled %>;
+  JST.project = <%= _.template(jstText).source %>;
 &lt;/script&gt;</pre>
 
 
diff --git a/test/utility.js b/test/utility.js
index 03577800a..a367dc1cf 100644
--- a/test/utility.js
+++ b/test/utility.js
@@ -178,11 +178,11 @@ $(document).ready(function() {
     strictEqual(_.result(null, 'x'), null);
   });
 
-  test('_.templateSettings.varname', function() {
+  test('_.templateSettings.variable', function() {
     var s = '<%=data.x%>';
     var data = {x: 'x'};
-    strictEqual(_.template(s, data, {varname: 'data'}), 'x')
-    _.templateSettings.varname = 'data';
+    strictEqual(_.template(s, data, {variable: 'data'}), 'x')
+    _.templateSettings.variable = 'data';
     strictEqual(_.template(s)(data), 'x')
   });
 
diff --git a/underscore.js b/underscore.js
index 30ba01ed5..5cf516b80 100644
--- a/underscore.js
+++ b/underscore.js
@@ -951,13 +951,13 @@
   // JavaScript micro-templating, similar to John Resig's implementation.
   // Underscore templating handles arbitrary delimiters, preserves whitespace,
   // and correctly escapes quotes within interpolated code.
-  _.template = function(source, data, settings) {
+  _.template = function(text, data, settings) {
     settings = _.extend(_.templateSettings, settings);
 
     // Compile the template source, taking care to escape characters that
     // cannot be included in a string literal and then unescape them in code
     // blocks.
-    var compiled = "__p.push('" + source
+    var source = "__p.push('" + text
       .replace(escaper, function(match) {
         return '\\' + escapes[match];
       })
@@ -971,13 +971,13 @@
         return "');\n" + unescape(code) + "\n;__p.push('";
       }) + "');\n";
 
-    // If no varname is specified, place data values in local scope.
-    if (!settings.varname) compiled = 'with(obj||{}){\n' + compiled + '}\n';
+    // If a variable is not specified, place data values in local scope.
+    if (!settings.variable) source = 'with(obj||{}){\n' + source + '}\n';
 
-    compiled = 'var __p=[],print=function(){__p.push.apply(__p,arguments);};\n' +
-      compiled + "return __p.join('');\n";
+    source = 'var __p=[],print=function(){__p.push.apply(__p,arguments);};\n' +
+      source + "return __p.join('');\n";
 
-    var render = new Function(settings.varname || 'obj', '_', compiled);
+    var render = new Function(settings.variable || 'obj', '_', source);
     if (data) return render(data, _);
     var template = function(data) {
       return render.call(this, data, _);
@@ -985,8 +985,8 @@
 
     // Provide the compiled function source as a convenience for build time
     // precompilation.
-    template.compiled = 'function(' + (settings.varname || 'obj') + '){\n' +
-      compiled + '\n}';
+    template.source = 'function(' + (settings.variable || 'obj') + '){\n' +
+      source + '\n}';
 
     return template;
   };
