third_party/jstemplate/jstemplate_example.js

   1 // Copyright 2006 Google Inc.
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6 //
   7 // http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
  12 // implied. See the License for the specific language governing
  13 // permissions and limitations under the License.
  14 /**
  15  * @pageoverview Some logic for the jstemplates test pages.
  16  *
  17  * @author Steffen Meschkat (mesch@google.com)
  18  */
  19
  20
  21 function elem(id) {
  22   return document.getElementById(id);
  23 }
  24
  25 /**
  26  * Are we actively profiling JstProcessor?
  27  * @type boolean
  28  */
  29 var profiling = false;
  30
  31 logHtml = function(html) {
  32   elem('log').innerHTML += html + '<br/>';
  33 };
  34
  35
  36 /**
  37  * Initializer for interactive test: copies the value from the actual
  38  * template HTML into a text area to make the HTML source visible.
  39  */
  40 function jsinit() {
  41   elem('template').value = elem('tc').innerHTML;
  42 }
  43
  44
  45 /**
  46  * Interactive test.
  47  *
  48  * @param {boolean} reprocess If true, reprocesses the output of the
  49  * previous invocation.
  50  */
  51 function jstest(reprocess) {
  52   var jstext = elem('js').value;
  53   var input = jsEval(jstext);
  54   var t;
  55   if (reprocess) {
  56     t = elem('out');
  57   } else {
  58     elem('tc').innerHTML = elem('template').value;
  59     t = jstGetTemplate('t');
  60     elem('out').innerHTML = '';
  61     elem('out').appendChild(t);
  62   }
  63   if (profiling) Profiler.reset();
  64   jstProcess(new JsEvalContext(input), t);
  65   if (profiling) Profiler.dump();
  66   elem('html').value = elem('out').innerHTML;
  67 }
  68
  69
  70 /**
  71  * Performance test: jst initial processing.
  72  *
  73  * @param {Object} data Test data to apply the template to.
  74  */
  75 function perf1(data) {
  76   elem('out').innerHTML = '';
  77   var t = jstGetTemplate('t1');
  78   elem('out').appendChild(t);
  79   if (profiling) Profiler.reset();
  80   jstProcess(new JsEvalContext(data), t);
  81   if (profiling) Profiler.dump();
  82 }
  83
  84
  85 /**
  86  * Performance test: jst reprocessing or previous processing output.
  87  *
  88  * @param {Object} data Test data to apply the template to.
  89  */
  90 function perf1a(data) {
  91   if (profiling) Profiler.reset();
  92   jstProcess(new JsEvalContext(data), elemOrDie('out'));
  93   if (profiling) Profiler.dump();
  94 }
  95
  96
  97 /**
  98  * Performance test: jst initial processing, with display:none during
  99  * processing.
 100  *
 101  * @param {Object} data Test data to apply the template to.
 102  */
 103 function perf1b(data) {
 104   var o = elem('out');
 105   o.innerHTML = '';
 106   var t = jstGetTemplate('t1');
 107   o.appendChild(t);
 108   displayNone(o);
 109   if (profiling) Profiler.reset();
 110   jstProcess(new JsEvalContext(data), t);
 111   if (profiling) Profiler.dump();
 112   displayDefault(o);
 113 }
 114
 115
 116 /**
 117  * Performance test: create output procedurally as string and assign
 118  * to innerHTML.
 119  *
 120  * @param {Object} data Test data to apply the template to.
 121  */
 122 function perf2(data) {
 123   var t = [];
 124   t.push("<table><tr><th>item</th><th>label</th><th>address</th></tr>");
 125   for (var i = 0; i < data.entries.length; ++i) {
 126     var e = data.entries[i];
 127     t.push("<tr><td>" + i + "</td><td>" + e.label + "</td><td>" +
 128            e.address + "</td></tr>");
 129   }
 130   t.push("</table>");
 131   elem("out").innerHTML = t.join('');
 132 }
 133
 134
 135 /**
 136  * A test runner for a test. Does the timing. @constructor
 137  *
 138  * @param {number} times number of iterations the test is executed.
 139  * @param {Function} test The test to execute.
 140  * @param {Function} result Function will be called with the execution
 141  * time as argument.
 142  */
 143 function TestRun(times, test, result) {
 144   this.count_ = 0;
 145   this.times_ = times;
 146   this.test_ = test;
 147   this.result_ = result;
 148   this.start_ = (new Date).valueOf();
 149   this.run_();
 150 }
 151
 152
 153 /**
 154  * Executes the test run.
 155  */
 156 TestRun.prototype.run_ = function() {
 157   if (this.count_ < this.times_) {
 158     this.test_(this.count_);
 159     this.count_ += 1;
 160     objectSetTimeout(this, this.run_, 0);
 161   } else {
 162     this.stop_ = (new Date).valueOf();
 163     this.result_(this.stop_ - this.start_);
 164   }
 165 };
 166
 167
 168 /**
 169  * Creates a testrun function for test count invocations of function
 170  * f, whose runtime will be output to the element with is given in
 171  * result.
 172  *
 173  * @param {Object} data The test data object.
 174  * @param {Function} f
 175  * @param {number} count
 176  * @param {string} result
 177 */
 178 function createTestRun(count, test) {
 179   var data = {
 180     entries: []
 181   };
 182   for (var i = 0; i < count; ++i) {
 183     data.entries.push({ label: "label" + i, address: "address" + i });
 184   }
 185   // This function is passed to the TimeoutSequence, and receives the
 186   // TimeoutSequence as argument on invocation.
 187   return function(s) {
 188     new TestRun(1, function(i) {
 189       window[test](data);
 190     }, function(time) {
 191       elem(test + '-' + count).innerHTML = time + 'ms';
 192       s.run();
 193     });
 194   };
 195 }
 196
 197 /**
 198  * Runs all tests the given number of times. Invoked from the HTML page.
 199  *
 200  * @param {number} count
 201  */
 202 function jsperf(count) {
 203   elemOrDie('log').innerHTML = '';
 204   profiling = !!elemOrDie('profile').checked;
 205   if (profiling && !JstProcessor.profiling_) {
 206     JstProcessor.profiling_ = true;
 207     Profiler.monitorAll(proto(JstProcessor), false);
 208   }
 209
 210   var s = new TimeoutSequence(null, null, true);
 211
 212   s.add(createTestRun(count, "perf1"));
 213   s.add(createTestRun(count, "perf1b"));
 214   s.add(createTestRun(count, "perf1a"));
 215   s.add(createTestRun(count, "perf2"));
 216
 217   s.run();
 218 }
 219
 220 function run(test, count) {
 221   var data = {
 222     entries: []
 223   };
 224   for (var i = 0; i < count; ++i) {
 225     data.entries.push({ label: "label" + i, address: "address" + i });
 226   }
 227   new TestRun(1, function() {
 228     window[test](data);
 229   }, function(time) {
 230     elem(test + '-' + count).innerHTML = time + 'ms';
 231   });
 232 }