← Back to branch summary

~michael.nelson/ubuntu-webcatalog/1267731-import-sca-apps-error

« back to all changes in this revision

Viewing changes to src/webcatalog/static/yui/3.10.3/build/handlebars-base/handlebars-base.js

  • Committer: Tarmac
  • Author(s): Stephen Stewart
  • Date: 2013-06-26 09:19:32 UTC
  • mfrom: (184.1.4 ubuntu-global-nav)
  • Revision ID: tarmac-20130626091932-8urtuli368k8p7ds
[r=beuno,jonas-drange] add ubuntu global nav to apps.ubuntu.com

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/webcatalog/static/yui/3.10.3/build/handlebars-base/handlebars-base.js
 
1
/*
 
2
YUI 3.10.3 (build 2fb5187)
 
3
Copyright 2013 Yahoo! Inc. All rights reserved.
 
4
Licensed under the BSD License.
 
5
http://yuilibrary.com/license/
 
6
*/
 
7
 
 
8
YUI.add('handlebars-base', function (Y, NAME) {
 
9
 
 
10
/*!
 
11
Handlebars.js - Copyright (C) 2011 Yehuda Katz
 
12
https://raw.github.com/wycats/handlebars.js/master/LICENSE
 
13
*/
 
14
// This file contains YUI-specific wrapper code and overrides for the
 
15
// handlebars-base module.
 
16
 
 
17
/**
 
18
Handlebars is a simple template language inspired by Mustache.
 
19
 
 
20
This is a YUI port of the original Handlebars project, which can be found at
 
21
<https://github.com/wycats/handlebars.js>.
 
22
 
 
23
@module handlebars
 
24
@main handlebars
 
25
@since 3.5.0
 
26
*/
 
27
 
 
28
/**
 
29
Provides basic Handlebars template rendering functionality. Use this module when
 
30
you only need to render pre-compiled templates.
 
31
 
 
32
@module handlebars
 
33
@submodule handlebars-base
 
34
*/
 
35
 
 
36
/**
 
37
Handlebars is a simple template language inspired by Mustache.
 
38
 
 
39
This is a YUI port of the original Handlebars project, which can be found at
 
40
<https://github.com/wycats/handlebars.js>.
 
41
 
 
42
@class Handlebars
 
43
@since 3.5.0
 
44
*/
 
45
var Handlebars = Y.namespace('Handlebars');
 
46
/* THIS FILE IS GENERATED BY A BUILD SCRIPT - DO NOT EDIT! */
 
47
 
 
48
Handlebars.VERSION = "1.0.0-rc.4";
 
49
Handlebars.COMPILER_REVISION = 3;
 
50
 
 
51
Handlebars.REVISION_CHANGES = {
 
52
  1: '<= 1.0.rc.2', // 1.0.rc.2 is actually rev2 but doesn't report it
 
53
  2: '== 1.0.0-rc.3',
 
54
  3: '>= 1.0.0-rc.4'
 
55
};
 
56
 
 
57
Handlebars.helpers  = {};
 
58
Handlebars.partials = {};
 
59
 
 
60
var toString = Object.prototype.toString,
 
61
    functionType = '[object Function]',
 
62
    objectType = '[object Object]';
 
63
 
 
64
Handlebars.registerHelper = function(name, fn, inverse) {
 
65
  if (toString.call(name) === objectType) {
 
66
    if (inverse || fn) { throw new Handlebars.Exception('Arg not supported with multiple helpers'); }
 
67
    Handlebars.Utils.extend(this.helpers, name);
 
68
  } else {
 
69
    if (inverse) { fn.not = inverse; }
 
70
    this.helpers[name] = fn;
 
71
  }
 
72
};
 
73
 
 
74
Handlebars.registerPartial = function(name, str) {
 
75
  if (toString.call(name) === objectType) {
 
76
    Handlebars.Utils.extend(this.partials,  name);
 
77
  } else {
 
78
    this.partials[name] = str;
 
79
  }
 
80
};
 
81
 
 
82
Handlebars.registerHelper('helperMissing', function(arg) {
 
83
  if(arguments.length === 2) {
 
84
    return undefined;
 
85
  } else {
 
86
    throw new Error("Could not find property '" + arg + "'");
 
87
  }
 
88
});
 
89
 
 
90
Handlebars.registerHelper('blockHelperMissing', function(context, options) {
 
91
  var inverse = options.inverse || function() {}, fn = options.fn;
 
92
 
 
93
  var type = toString.call(context);
 
94
 
 
95
  if(type === functionType) { context = context.call(this); }
 
96
 
 
97
  if(context === true) {
 
98
    return fn(this);
 
99
  } else if(context === false || context == null) {
 
100
    return inverse(this);
 
101
  } else if(type === "[object Array]") {
 
102
    if(context.length > 0) {
 
103
      return Handlebars.helpers.each(context, options);
 
104
    } else {
 
105
      return inverse(this);
 
106
    }
 
107
  } else {
 
108
    return fn(context);
 
109
  }
 
110
});
 
111
 
 
112
Handlebars.K = function() {};
 
113
 
 
114
Handlebars.createFrame = Object.create || function(object) {
 
115
  Handlebars.K.prototype = object;
 
116
  var obj = new Handlebars.K();
 
117
  Handlebars.K.prototype = null;
 
118
  return obj;
 
119
};
 
120
 
 
121
Handlebars.logger = {
 
122
  DEBUG: 0, INFO: 1, WARN: 2, ERROR: 3, level: 3,
 
123
 
 
124
  methodMap: {0: 'debug', 1: 'info', 2: 'warn', 3: 'error'},
 
125
 
 
126
  // can be overridden in the host environment
 
127
  log: function(level, obj) {
 
128
    if (Handlebars.logger.level <= level) {
 
129
      var method = Handlebars.logger.methodMap[level];
 
130
      if (typeof console !== 'undefined' && console[method]) {
 
131
        console[method].call(console, obj);
 
132
      }
 
133
    }
 
134
  }
 
135
};
 
136
 
 
137
Handlebars.log = function(level, obj) { Handlebars.logger.log(level, obj); };
 
138
 
 
139
Handlebars.registerHelper('each', function(context, options) {
 
140
  var fn = options.fn, inverse = options.inverse;
 
141
  var i = 0, ret = "", data;
 
142
 
 
143
  if (options.data) {
 
144
    data = Handlebars.createFrame(options.data);
 
145
  }
 
146
 
 
147
  if(context && typeof context === 'object') {
 
148
    if(context instanceof Array){
 
149
      for(var j = context.length; i<j; i++) {
 
150
        if (data) { data.index = i; }
 
151
        ret = ret + fn(context[i], { data: data });
 
152
      }
 
153
    } else {
 
154
      for(var key in context) {
 
155
        if(context.hasOwnProperty(key)) {
 
156
          if(data) { data.key = key; }
 
157
          ret = ret + fn(context[key], {data: data});
 
158
          i++;
 
159
        }
 
160
      }
 
161
    }
 
162
  }
 
163
 
 
164
  if(i === 0){
 
165
    ret = inverse(this);
 
166
  }
 
167
 
 
168
  return ret;
 
169
});
 
170
 
 
171
Handlebars.registerHelper('if', function(context, options) {
 
172
  var type = toString.call(context);
 
173
  if(type === functionType) { context = context.call(this); }
 
174
 
 
175
  if(!context || Handlebars.Utils.isEmpty(context)) {
 
176
    return options.inverse(this);
 
177
  } else {
 
178
    return options.fn(this);
 
179
  }
 
180
});
 
181
 
 
182
Handlebars.registerHelper('unless', function(context, options) {
 
183
  return Handlebars.helpers['if'].call(this, context, {fn: options.inverse, inverse: options.fn});
 
184
});
 
185
 
 
186
Handlebars.registerHelper('with', function(context, options) {
 
187
  if (!Handlebars.Utils.isEmpty(context)) return options.fn(context);
 
188
});
 
189
 
 
190
Handlebars.registerHelper('log', function(context, options) {
 
191
  var level = options.data && options.data.level != null ? parseInt(options.data.level, 10) : 1;
 
192
  Handlebars.log(level, context);
 
193
});
 
194
/* THIS FILE IS GENERATED BY A BUILD SCRIPT - DO NOT EDIT! */
 
195
 
 
196
var errorProps = ['description', 'fileName', 'lineNumber', 'message', 'name', 'number', 'stack'];
 
197
 
 
198
Handlebars.Exception = function(message) {
 
199
  var tmp = Error.prototype.constructor.apply(this, arguments);
 
200
 
 
201
  // Unfortunately errors are not enumerable in Chrome (at least), so `for prop in tmp` doesn't work.
 
202
  for (var idx = 0; idx < errorProps.length; idx++) {
 
203
    this[errorProps[idx]] = tmp[errorProps[idx]];
 
204
  }
 
205
};
 
206
Handlebars.Exception.prototype = new Error();
 
207
 
 
208
// Build out our basic SafeString type
 
209
Handlebars.SafeString = function(string) {
 
210
  this.string = string;
 
211
};
 
212
Handlebars.SafeString.prototype.toString = function() {
 
213
  return this.string.toString();
 
214
};
 
215
 
 
216
var escape = {
 
217
  "&": "&amp;",
 
218
  "<": "&lt;",
 
219
  ">": "&gt;",
 
220
  '"': "&quot;",
 
221
  "'": "&#x27;",
 
222
  "`": "&#x60;"
 
223
};
 
224
 
 
225
var badChars = /[&<>"'`]/g;
 
226
var possible = /[&<>"'`]/;
 
227
 
 
228
var escapeChar = function(chr) {
 
229
  return escape[chr] || "&amp;";
 
230
};
 
231
 
 
232
Handlebars.Utils = {
 
233
  extend: function(obj, value) {
 
234
    for(var key in value) {
 
235
      if(value.hasOwnProperty(key)) {
 
236
        obj[key] = value[key];
 
237
      }
 
238
    }
 
239
  },
 
240
 
 
241
  escapeExpression: function(string) {
 
242
    // don't escape SafeStrings, since they're already safe
 
243
    if (string instanceof Handlebars.SafeString) {
 
244
      return string.toString();
 
245
    } else if (string == null || string === false) {
 
246
      return "";
 
247
    }
 
248
 
 
249
    // Force a string conversion as this will be done by the append regardless and
 
250
    // the regex test will do this transparently behind the scenes, causing issues if
 
251
    // an object's to string has escaped characters in it.
 
252
    string = string.toString();
 
253
 
 
254
    if(!possible.test(string)) { return string; }
 
255
    return string.replace(badChars, escapeChar);
 
256
  },
 
257
 
 
258
  isEmpty: function(value) {
 
259
    if (!value && value !== 0) {
 
260
      return true;
 
261
    } else if(toString.call(value) === "[object Array]" && value.length === 0) {
 
262
      return true;
 
263
    } else {
 
264
      return false;
 
265
    }
 
266
  }
 
267
};
 
268
/* THIS FILE IS GENERATED BY A BUILD SCRIPT - DO NOT EDIT! */
 
269
 
 
270
Handlebars.VM = {
 
271
  template: function(templateSpec) {
 
272
    // Just add water
 
273
    var container = {
 
274
      escapeExpression: Handlebars.Utils.escapeExpression,
 
275
      invokePartial: Handlebars.VM.invokePartial,
 
276
      programs: [],
 
277
      program: function(i, fn, data) {
 
278
        var programWrapper = this.programs[i];
 
279
        if(data) {
 
280
          programWrapper = Handlebars.VM.program(i, fn, data);
 
281
        } else if (!programWrapper) {
 
282
          programWrapper = this.programs[i] = Handlebars.VM.program(i, fn);
 
283
        }
 
284
        return programWrapper;
 
285
      },
 
286
      programWithDepth: Handlebars.VM.programWithDepth,
 
287
      noop: Handlebars.VM.noop,
 
288
      compilerInfo: null
 
289
    };
 
290
 
 
291
    return function(context, options) {
 
292
      options = options || {};
 
293
      var result = templateSpec.call(container, Handlebars, context, options.helpers, options.partials, options.data);
 
294
 
 
295
      var compilerInfo = container.compilerInfo || [],
 
296
          compilerRevision = compilerInfo[0] || 1,
 
297
          currentRevision = Handlebars.COMPILER_REVISION;
 
298
 
 
299
      if (compilerRevision !== currentRevision) {
 
300
        if (compilerRevision < currentRevision) {
 
301
          var runtimeVersions = Handlebars.REVISION_CHANGES[currentRevision],
 
302
              compilerVersions = Handlebars.REVISION_CHANGES[compilerRevision];
 
303
          throw "Template was precompiled with an older version of Handlebars than the current runtime. "+
 
304
                "Please update your precompiler to a newer version ("+runtimeVersions+") or downgrade your runtime to an older version ("+compilerVersions+").";
 
305
        } else {
 
306
          // Use the embedded version info since the runtime doesn't know about this revision yet
 
307
          throw "Template was precompiled with a newer version of Handlebars than the current runtime. "+
 
308
                "Please update your runtime to a newer version ("+compilerInfo[1]+").";
 
309
        }
 
310
      }
 
311
 
 
312
      return result;
 
313
    };
 
314
  },
 
315
 
 
316
  programWithDepth: function(i, fn, data /*, $depth */) {
 
317
    var args = Array.prototype.slice.call(arguments, 3);
 
318
 
 
319
    var program = function(context, options) {
 
320
      options = options || {};
 
321
 
 
322
      return fn.apply(this, [context, options.data || data].concat(args));
 
323
    };
 
324
    program.program = i;
 
325
    program.depth = args.length;
 
326
    return program;
 
327
  },
 
328
  program: function(i, fn, data) {
 
329
    var program = function(context, options) {
 
330
      options = options || {};
 
331
 
 
332
      return fn(context, options.data || data);
 
333
    };
 
334
    program.program = i;
 
335
    program.depth = 0;
 
336
    return program;
 
337
  },
 
338
  noop: function() { return ""; },
 
339
  invokePartial: function(partial, name, context, helpers, partials, data) {
 
340
    var options = { helpers: helpers, partials: partials, data: data };
 
341
 
 
342
    if(partial === undefined) {
 
343
      throw new Handlebars.Exception("The partial " + name + " could not be found");
 
344
    } else if(partial instanceof Function) {
 
345
      return partial(context, options);
 
346
    } else if (!Handlebars.compile) {
 
347
      throw new Handlebars.Exception("The partial " + name + " could not be compiled when running in runtime-only mode");
 
348
    } else {
 
349
      partials[name] = Handlebars.compile(partial, {data: data !== undefined});
 
350
      return partials[name](context, options);
 
351
    }
 
352
  }
 
353
};
 
354
 
 
355
Handlebars.template = Handlebars.VM.template;
 
356
// This file contains YUI-specific wrapper code and overrides for the
 
357
// handlebars-base module.
 
358
 
 
359
Handlebars.VERSION += '-yui';
 
360
 
 
361
/**
 
362
Registers a helper function that will be made available to all templates.
 
363
 
 
364
Helper functions receive the current template context as the `this` object, and
 
365
can also receive arguments passed by the template.
 
366
 
 
367
@example
 
368
 
 
369
    Y.Handlebars.registerHelper('linkify', function () {
 
370
        return '<a href="' + Y.Escape.html(this.url) + '">' +
 
371
            Y.Escape.html(this.text) + '</a>';
 
372
    });
 
373
 
 
374
    var source = '<ul>{{#links}}<li>{{{linkify}}}</li>{{/links}}</ul>';
 
375
 
 
376
    Y.Handlebars.render(source, {
 
377
        links: [
 
378
            {url: '/foo', text: 'Foo'},
 
379
            {url: '/bar', text: 'Bar'},
 
380
            {url: '/baz', text: 'Baz'}
 
381
        ]
 
382
    });
 
383
 
 
384
@method registerHelper
 
385
@param {String} name Name of this helper.
 
386
@param {Function} fn Helper function.
 
387
@param {Boolean} [inverse=false] If `true`, this helper will be considered an
 
388
    "inverse" helper, like "unless". This means it will only be called if the
 
389
    expression given in the template evaluates to a false or empty value.
 
390
*/
 
391
 
 
392
/**
 
393
Registers a partial that will be made available to all templates.
 
394
 
 
395
A partial is another template that can be used to render part of a larger
 
396
template. For example, a website with a common header and footer across all its
 
397
pages might use a template for each page, which would call shared partials to
 
398
render the headers and footers.
 
399
 
 
400
Partials may be specified as uncompiled template strings or as compiled template
 
401
functions.
 
402
 
 
403
@example
 
404
 
 
405
    Y.Handlebars.registerPartial('header', '<h1>{{title}}</h1>');
 
406
    Y.Handlebars.registerPartial('footer', 'Copyright (c) 2011 by Me.');
 
407
 
 
408
    var source = '{{> header}} <p>Mustaches are awesome!</p> {{> footer}}';
 
409
 
 
410
    Y.Handlebars.render(source, {title: 'My Page About Mustaches'});
 
411
 
 
412
@method registerPartial
 
413
@param {String} name Name of this partial.
 
414
@param {Function|String} partial Template string or compiled template function.
 
415
*/
 
416
 
 
417
/**
 
418
Converts a precompiled template into a renderable template function.
 
419
 
 
420
@example
 
421
 
 
422
    <script src="precompiled-template.js"></script>
 
423
    <script>
 
424
    YUI().use('handlebars-base', function (Y) {
 
425
        // Convert the precompiled template function into a renderable template
 
426
        // function.
 
427
        var template = Y.Handlebars.template(precompiledTemplate);
 
428
 
 
429
        // Render it.
 
430
        template({pie: 'Pumpkin'});
 
431
    });
 
432
    </script>
 
433
 
 
434
@method template
 
435
@param {Function} template Precompiled Handlebars template function.
 
436
@return {Function} Compiled template function.
 
437
*/
 
438
 
 
439
// Alias for Y.Handlebars.template(), used by Y.Template.
 
440
Handlebars.revive = Handlebars.template;
 
441
 
 
442
// Make Y.Template.Handlebars an alias for Y.Handlebars.
 
443
Y.namespace('Template').Handlebars = Handlebars;
 
444
 
 
445
 
 
446
}, '3.10.3', {"requires": []});