handlebars-amd-rails 1.0.0.rc.3

data/vendor/assets/javascripts/handlebars-runtime.js

@@ -0,0 +1,322 @@
+/*
+
+Copyright (C) 2011 by Yehuda Katz
+
+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.
+
+*/
+
+// lib/handlebars/browser-prefix.js
+(function () {
+
+  var Handlebars = {};
+
+  define('handlebars', function () {
+    return Handlebars;
+  });
+
+  (function(Handlebars, undefined) {
+  ;
+  // lib/handlebars/base.js
+
+  Handlebars.VERSION = "1.0.0-rc.3";
+  Handlebars.COMPILER_REVISION = 2;
+
+  Handlebars.REVISION_CHANGES = {
+    1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
+    2: '>= 1.0.0-rc.3'
+  };
+
+  Handlebars.helpers  = {};
+  Handlebars.partials = {};
+
+  Handlebars.registerHelper = function(name, fn, inverse) {
+    if(inverse) { fn.not = inverse; }
+    this.helpers[name] = fn;
+  };
+
+  Handlebars.registerPartial = function(name, str) {
+    this.partials[name] = str;
+  };
+
+  Handlebars.registerHelper('helperMissing', function(arg) {
+    if(arguments.length === 2) {
+      return undefined;
+    } else {
+      throw new Error("Could not find property '" + arg + "'");
+    }
+  });
+
+  var toString = Object.prototype.toString, functionType = "[object Function]";
+
+  Handlebars.registerHelper('blockHelperMissing', function(context, options) {
+    var inverse = options.inverse || function() {}, fn = options.fn;
+
+    var type = toString.call(context);
+
+    if(type === functionType) { context = context.call(this); }
+
+    if(context === true) {
+      return fn(this);
+    } else if(context === false || context == null) {
+      return inverse(this);
+    } else if(type === "[object Array]") {
+      if(context.length > 0) {
+        return Handlebars.helpers.each(context, options);
+      } else {
+        return inverse(this);
+      }
+    } else {
+      return fn(context);
+    }
+  });
+
+  Handlebars.K = function() {};
+
+  Handlebars.createFrame = Object.create || function(object) {
+    Handlebars.K.prototype = object;
+    var obj = new Handlebars.K();
+    Handlebars.K.prototype = null;
+    return obj;
+  };
+
+  Handlebars.logger = {
+    DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, level: 3,
+
+    methodMap: {0: 'debug', 1: 'info', 2: 'warn', 3: 'error'},
+
+    // can be overridden in the host environment
+    log: function(level, obj) {
+      if (Handlebars.logger.level <= level) {
+        var method = Handlebars.logger.methodMap[level];
+        if (typeof console !== 'undefined' && console[method]) {
+          console[method].call(console, obj);
+        }
+      }
+    }
+  };
+
+  Handlebars.log = function(level, obj) { Handlebars.logger.log(level, obj); };
+
+  Handlebars.registerHelper('each', function(context, options) {
+    var fn = options.fn, inverse = options.inverse;
+    var i = 0, ret = "", data;
+
+    if (options.data) {
+      data = Handlebars.createFrame(options.data);
+    }
+
+    if(context && typeof context === 'object') {
+      if(context instanceof Array){
+        for(var j = context.length; i<j; i++) {
+          if (data) { data.index = i; }
+          ret = ret + fn(context[i], { data: data });
+        }
+      } else {
+        for(var key in context) {
+          if(context.hasOwnProperty(key)) {
+            if(data) { data.key = key; }
+            ret = ret + fn(context[key], {data: data});
+            i++;
+          }
+        }
+      }
+    }
+
+    if(i === 0){
+      ret = inverse(this);
+    }
+
+    return ret;
+  });
+
+  Handlebars.registerHelper('if', function(context, options) {
+    var type = toString.call(context);
+    if(type === functionType) { context = context.call(this); }
+
+    if(!context || Handlebars.Utils.isEmpty(context)) {
+      return options.inverse(this);
+    } else {
+      return options.fn(this);
+    }
+  });
+
+  Handlebars.registerHelper('unless', function(context, options) {
+    return Handlebars.helpers['if'].call(this, context, {fn: options.inverse, inverse: options.fn});
+  });
+
+  Handlebars.registerHelper('with', function(context, options) {
+    return options.fn(context);
+  });
+
+  Handlebars.registerHelper('log', function(context, options) {
+    var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
+    Handlebars.log(level, context);
+  });
+  ;
+  // lib/handlebars/utils.js
+
+  var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
+
+  Handlebars.Exception = function(message) {
+    var tmp = Error.prototype.constructor.apply(this, arguments);
+
+    // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
+    for (var idx = 0; idx < errorProps.length; idx++) {
+      this[errorProps[idx]] = tmp[errorProps[idx]];
+    }
+  };
+  Handlebars.Exception.prototype = new Error();
+
+  // Build out our basic SafeString type
+  Handlebars.SafeString = function(string) {
+    this.string = string;
+  };
+  Handlebars.SafeString.prototype.toString = function() {
+    return this.string.toString();
+  };
+
+  var escape = {
+    "&": "&amp;",
+    "<": "&lt;",
+    ">": "&gt;",
+    '"': "&quot;",
+    "'": "&#x27;",
+    "`": "&#x60;"
+  };
+
+  var badChars = /[&<>"'`]/g;
+  var possible = /[&<>"'`]/;
+
+  var escapeChar = function(chr) {
+    return escape[chr] || "&amp;";
+  };
+
+  Handlebars.Utils = {
+    escapeExpression: function(string) {
+      // don't escape SafeStrings, since they're already safe
+      if (string instanceof Handlebars.SafeString) {
+        return string.toString();
+      } else if (string == null || string === false) {
+        return "";
+      }
+
+      if(!possible.test(string)) { return string; }
+      return string.replace(badChars, escapeChar);
+    },
+
+    isEmpty: function(value) {
+      if (!value && value !== 0) {
+        return true;
+      } else if(toString.call(value) === "[object Array]" && value.length === 0) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+  };
+  ;
+  // lib/handlebars/runtime.js
+
+  Handlebars.VM = {
+    template: function(templateSpec) {
+      // Just add water
+      var container = {
+        escapeExpression: Handlebars.Utils.escapeExpression,
+        invokePartial: Handlebars.VM.invokePartial,
+        programs: [],
+        program: function(i, fn, data) {
+          var programWrapper = this.programs[i];
+          if(data) {
+            return Handlebars.VM.program(fn, data);
+          } else if(programWrapper) {
+            return programWrapper;
+          } else {
+            programWrapper = this.programs[i] = Handlebars.VM.program(fn);
+            return programWrapper;
+          }
+        },
+        programWithDepth: Handlebars.VM.programWithDepth,
+        noop: Handlebars.VM.noop,
+        compilerInfo: null
+      };
+
+      return function(context, options) {
+        options = options || {};
+        var result = templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
+
+        var compilerInfo = container.compilerInfo || [],
+            compilerRevision = compilerInfo[0] || 1,
+            currentRevision = Handlebars.COMPILER_REVISION;
+
+        if (compilerRevision !== currentRevision) {
+          if (compilerRevision < currentRevision) {
+            var runtimeVersions = Handlebars.REVISION_CHANGES[currentRevision],
+                compilerVersions = Handlebars.REVISION_CHANGES[compilerRevision];
+            throw "Template was precompiled with an older version of Handlebars than the current runtime. "+
+                  "Please update your precompiler to a newer version ("+runtimeVersions+") or downgrade your runtime to an older version ("+compilerVersions+").";
+          } else {
+            // Use the embedded version info since the runtime doesn't know about this revision yet
+            throw "Template was precompiled with a newer version of Handlebars than the current runtime. "+
+                  "Please update your runtime to a newer version ("+compilerInfo[1]+").";
+          }
+        }
+
+        return result;
+      };
+    },
+
+    programWithDepth: function(fn, data, $depth) {
+      var args = Array.prototype.slice.call(arguments, 2);
+
+      return function(context, options) {
+        options = options || {};
+
+        return fn.apply(this, [context, options.data || data].concat(args));
+      };
+    },
+    program: function(fn, data) {
+      return function(context, options) {
+        options = options || {};
+
+        return fn(context, options.data || data);
+      };
+    },
+    noop: function() { return ""; },
+    invokePartial: function(partial, name, context, helpers, partials, data) {
+      var options = { helpers: helpers, partials: partials, data: data };
+
+      if(partial === undefined) {
+        throw new Handlebars.Exception("The partial " + name + " could not be found");
+      } else if(partial instanceof Function) {
+        return partial(context, options);
+      } else if (!Handlebars.compile) {
+        throw new Handlebars.Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
+      } else {
+        partials[name] = Handlebars.compile(partial, {data: data !== undefined});
+        return partials[name](context, options);
+      }
+    }
+  };
+
+  Handlebars.template = Handlebars.VM.template;
+  ;
+  // lib/handlebars/browser-suffix.js
+  })(Handlebars);
+})();