dj_mon 1.0.2 → 1.0.3
Sign up to get free protection for your applications and to get access to all the features.
- data/lib/dj_mon/version.rb +1 -1
- data/vendor/assets/javascripts/dj_mon/bootstrap_modal.js +218 -0
- data/vendor/assets/javascripts/dj_mon/bootstrap_popover.js +98 -0
- data/vendor/assets/javascripts/dj_mon/bootstrap_tab.js +135 -0
- data/vendor/assets/javascripts/dj_mon/bootstrap_tooltip.js +275 -0
- data/vendor/assets/javascripts/dj_mon/mustache.js +536 -0
- data/vendor/assets/stylesheets/dj_mon/bootstrap.css +4592 -0
- metadata +7 -1
@@ -0,0 +1,536 @@
|
|
1
|
+
/*!
|
2
|
+
* mustache.js - Logic-less {{mustache}} templates with JavaScript
|
3
|
+
* http://github.com/janl/mustache.js
|
4
|
+
*/
|
5
|
+
var Mustache = (typeof module !== "undefined" && module.exports) || {};
|
6
|
+
|
7
|
+
(function (exports) {
|
8
|
+
|
9
|
+
exports.name = "mustache.js";
|
10
|
+
exports.version = "0.5.0-dev";
|
11
|
+
exports.tags = ["{{", "}}"];
|
12
|
+
exports.parse = parse;
|
13
|
+
exports.compile = compile;
|
14
|
+
exports.render = render;
|
15
|
+
exports.clearCache = clearCache;
|
16
|
+
|
17
|
+
// This is here for backwards compatibility with 0.4.x.
|
18
|
+
exports.to_html = function (template, view, partials, send) {
|
19
|
+
var result = render(template, view, partials);
|
20
|
+
|
21
|
+
if (typeof send === "function") {
|
22
|
+
send(result);
|
23
|
+
} else {
|
24
|
+
return result;
|
25
|
+
}
|
26
|
+
};
|
27
|
+
|
28
|
+
var _toString = Object.prototype.toString;
|
29
|
+
var _isArray = Array.isArray;
|
30
|
+
var _forEach = Array.prototype.forEach;
|
31
|
+
var _trim = String.prototype.trim;
|
32
|
+
|
33
|
+
var isArray;
|
34
|
+
if (_isArray) {
|
35
|
+
isArray = _isArray;
|
36
|
+
} else {
|
37
|
+
isArray = function (obj) {
|
38
|
+
return _toString.call(obj) === "[object Array]";
|
39
|
+
};
|
40
|
+
}
|
41
|
+
|
42
|
+
var forEach;
|
43
|
+
if (_forEach) {
|
44
|
+
forEach = function (obj, callback, scope) {
|
45
|
+
return _forEach.call(obj, callback, scope);
|
46
|
+
};
|
47
|
+
} else {
|
48
|
+
forEach = function (obj, callback, scope) {
|
49
|
+
for (var i = 0, len = obj.length; i < len; ++i) {
|
50
|
+
callback.call(scope, obj[i], i, obj);
|
51
|
+
}
|
52
|
+
};
|
53
|
+
}
|
54
|
+
|
55
|
+
var spaceRe = /^\s*$/;
|
56
|
+
|
57
|
+
function isWhitespace(string) {
|
58
|
+
return spaceRe.test(string);
|
59
|
+
}
|
60
|
+
|
61
|
+
var trim;
|
62
|
+
if (_trim) {
|
63
|
+
trim = function (string) {
|
64
|
+
return string == null ? "" : _trim.call(string);
|
65
|
+
};
|
66
|
+
} else {
|
67
|
+
var trimLeft, trimRight;
|
68
|
+
|
69
|
+
if (isWhitespace("\xA0")) {
|
70
|
+
trimLeft = /^\s+/;
|
71
|
+
trimRight = /\s+$/;
|
72
|
+
} else {
|
73
|
+
// IE doesn't match non-breaking spaces with \s, thanks jQuery.
|
74
|
+
trimLeft = /^[\s\xA0]+/;
|
75
|
+
trimRight = /[\s\xA0]+$/;
|
76
|
+
}
|
77
|
+
|
78
|
+
trim = function (string) {
|
79
|
+
return string == null ? "" :
|
80
|
+
String(string).replace(trimLeft, "").replace(trimRight, "");
|
81
|
+
};
|
82
|
+
}
|
83
|
+
|
84
|
+
var escapeMap = {
|
85
|
+
"&": "&",
|
86
|
+
"<": "<",
|
87
|
+
">": ">",
|
88
|
+
'"': '"',
|
89
|
+
"'": '''
|
90
|
+
};
|
91
|
+
|
92
|
+
function escapeHTML(string) {
|
93
|
+
return String(string).replace(/&(?!\w+;)|[<>"']/g, function (s) {
|
94
|
+
return escapeMap[s] || s;
|
95
|
+
});
|
96
|
+
}
|
97
|
+
|
98
|
+
/**
|
99
|
+
* Adds the `template`, `line`, and `file` properties to the given error
|
100
|
+
* object and alters the message to provide more useful debugging information.
|
101
|
+
*/
|
102
|
+
function debug(e, template, line, file) {
|
103
|
+
file = file || "<template>";
|
104
|
+
|
105
|
+
var lines = template.split("\n"),
|
106
|
+
start = Math.max(line - 3, 0),
|
107
|
+
end = Math.min(lines.length, line + 3),
|
108
|
+
context = lines.slice(start, end);
|
109
|
+
|
110
|
+
var c;
|
111
|
+
for (var i = 0, len = context.length; i < len; ++i) {
|
112
|
+
c = i + start + 1;
|
113
|
+
context[i] = (c === line ? " >> " : " ") + context[i];
|
114
|
+
}
|
115
|
+
|
116
|
+
e.template = template;
|
117
|
+
e.line = line;
|
118
|
+
e.file = file;
|
119
|
+
e.message = [file + ":" + line, context.join("\n"), "", e.message].join("\n");
|
120
|
+
|
121
|
+
return e;
|
122
|
+
}
|
123
|
+
|
124
|
+
/**
|
125
|
+
* Looks up the value of the given `name` in the given context `stack`.
|
126
|
+
*/
|
127
|
+
function lookup(name, stack, defaultValue) {
|
128
|
+
if (name === ".") {
|
129
|
+
return stack[stack.length - 1];
|
130
|
+
}
|
131
|
+
|
132
|
+
var names = name.split(".");
|
133
|
+
var lastIndex = names.length - 1;
|
134
|
+
var target = names[lastIndex];
|
135
|
+
|
136
|
+
var value, context, i = stack.length, j, localStack;
|
137
|
+
while (i) {
|
138
|
+
localStack = stack.slice(0);
|
139
|
+
context = stack[--i];
|
140
|
+
|
141
|
+
j = 0;
|
142
|
+
while (j < lastIndex) {
|
143
|
+
context = context[names[j++]];
|
144
|
+
|
145
|
+
if (context == null) {
|
146
|
+
break;
|
147
|
+
}
|
148
|
+
|
149
|
+
localStack.push(context);
|
150
|
+
}
|
151
|
+
|
152
|
+
if (context && typeof context === "object" && target in context) {
|
153
|
+
value = context[target];
|
154
|
+
break;
|
155
|
+
}
|
156
|
+
}
|
157
|
+
|
158
|
+
// If the value is a function, call it in the current context.
|
159
|
+
if (typeof value === "function") {
|
160
|
+
value = value.call(localStack[localStack.length - 1]);
|
161
|
+
}
|
162
|
+
|
163
|
+
if (value == null) {
|
164
|
+
return defaultValue;
|
165
|
+
}
|
166
|
+
|
167
|
+
return value;
|
168
|
+
}
|
169
|
+
|
170
|
+
function renderSection(name, stack, callback, inverted) {
|
171
|
+
var buffer = "";
|
172
|
+
var value = lookup(name, stack);
|
173
|
+
|
174
|
+
if (inverted) {
|
175
|
+
// From the spec: inverted sections may render text once based on the
|
176
|
+
// inverse value of the key. That is, they will be rendered if the key
|
177
|
+
// doesn't exist, is false, or is an empty list.
|
178
|
+
if (value == null || value === false || (isArray(value) && value.length === 0)) {
|
179
|
+
buffer += callback();
|
180
|
+
}
|
181
|
+
} else if (isArray(value)) {
|
182
|
+
forEach(value, function (value) {
|
183
|
+
stack.push(value);
|
184
|
+
buffer += callback();
|
185
|
+
stack.pop();
|
186
|
+
});
|
187
|
+
} else if (typeof value === "object") {
|
188
|
+
stack.push(value);
|
189
|
+
buffer += callback();
|
190
|
+
stack.pop();
|
191
|
+
} else if (typeof value === "function") {
|
192
|
+
var scope = stack[stack.length - 1];
|
193
|
+
var scopedRender = function (template) {
|
194
|
+
return render(template, scope);
|
195
|
+
};
|
196
|
+
buffer += value.call(scope, callback(), scopedRender) || "";
|
197
|
+
} else if (value) {
|
198
|
+
buffer += callback();
|
199
|
+
}
|
200
|
+
|
201
|
+
return buffer;
|
202
|
+
}
|
203
|
+
|
204
|
+
/**
|
205
|
+
* Parses the given `template` and returns the source of a function that,
|
206
|
+
* with the proper arguments, will render the template. Recognized options
|
207
|
+
* include the following:
|
208
|
+
*
|
209
|
+
* - file The name of the file the template comes from (displayed in
|
210
|
+
* error messages)
|
211
|
+
* - tags An array of open and close tags the `template` uses. Defaults
|
212
|
+
* to the value of Mustache.tags
|
213
|
+
* - debug Set `true` to log the body of the generated function to the
|
214
|
+
* console
|
215
|
+
* - space Set `true` to preserve whitespace from lines that otherwise
|
216
|
+
* contain only a {{tag}}. Defaults to `false`
|
217
|
+
*/
|
218
|
+
function parse(template, options) {
|
219
|
+
options = options || {};
|
220
|
+
|
221
|
+
var tags = options.tags || exports.tags,
|
222
|
+
openTag = tags[0],
|
223
|
+
closeTag = tags[tags.length - 1];
|
224
|
+
|
225
|
+
var code = [
|
226
|
+
'var buffer = "";', // output buffer
|
227
|
+
"\nvar line = 1;", // keep track of source line number
|
228
|
+
"\ntry {",
|
229
|
+
'\nbuffer += "'
|
230
|
+
];
|
231
|
+
|
232
|
+
var spaces = [], // indices of whitespace in code on the current line
|
233
|
+
hasTag = false, // is there a {{tag}} on the current line?
|
234
|
+
nonSpace = false; // is there a non-space char on the current line?
|
235
|
+
|
236
|
+
// Strips all space characters from the code array for the current line
|
237
|
+
// if there was a {{tag}} on it and otherwise only spaces.
|
238
|
+
var stripSpace = function () {
|
239
|
+
if (hasTag && !nonSpace && !options.space) {
|
240
|
+
while (spaces.length) {
|
241
|
+
code.splice(spaces.pop(), 1);
|
242
|
+
}
|
243
|
+
} else {
|
244
|
+
spaces = [];
|
245
|
+
}
|
246
|
+
|
247
|
+
hasTag = false;
|
248
|
+
nonSpace = false;
|
249
|
+
};
|
250
|
+
|
251
|
+
var sectionStack = [], updateLine, nextOpenTag, nextCloseTag;
|
252
|
+
|
253
|
+
var setTags = function (source) {
|
254
|
+
tags = trim(source).split(/\s+/);
|
255
|
+
nextOpenTag = tags[0];
|
256
|
+
nextCloseTag = tags[tags.length - 1];
|
257
|
+
};
|
258
|
+
|
259
|
+
var includePartial = function (source) {
|
260
|
+
code.push(
|
261
|
+
'";',
|
262
|
+
updateLine,
|
263
|
+
'\nvar partial = partials["' + trim(source) + '"];',
|
264
|
+
'\nif (partial) {',
|
265
|
+
'\n buffer += render(partial,stack[stack.length - 1],partials);',
|
266
|
+
'\n}',
|
267
|
+
'\nbuffer += "'
|
268
|
+
);
|
269
|
+
};
|
270
|
+
|
271
|
+
var openSection = function (source, inverted) {
|
272
|
+
var name = trim(source);
|
273
|
+
|
274
|
+
if (name === "") {
|
275
|
+
throw debug(new Error("Section name may not be empty"), template, line, options.file);
|
276
|
+
}
|
277
|
+
|
278
|
+
sectionStack.push({name: name, inverted: inverted});
|
279
|
+
|
280
|
+
code.push(
|
281
|
+
'";',
|
282
|
+
updateLine,
|
283
|
+
'\nvar name = "' + name + '";',
|
284
|
+
'\nvar callback = (function () {',
|
285
|
+
'\n return function () {',
|
286
|
+
'\n var buffer = "";',
|
287
|
+
'\nbuffer += "'
|
288
|
+
);
|
289
|
+
};
|
290
|
+
|
291
|
+
var openInvertedSection = function (source) {
|
292
|
+
openSection(source, true);
|
293
|
+
};
|
294
|
+
|
295
|
+
var closeSection = function (source) {
|
296
|
+
var name = trim(source);
|
297
|
+
var openName = sectionStack.length != 0 && sectionStack[sectionStack.length - 1].name;
|
298
|
+
|
299
|
+
if (!openName || name != openName) {
|
300
|
+
throw debug(new Error('Section named "' + name + '" was never opened'), template, line, options.file);
|
301
|
+
}
|
302
|
+
|
303
|
+
var section = sectionStack.pop();
|
304
|
+
|
305
|
+
code.push(
|
306
|
+
'";',
|
307
|
+
'\n return buffer;',
|
308
|
+
'\n };',
|
309
|
+
'\n})();'
|
310
|
+
);
|
311
|
+
|
312
|
+
if (section.inverted) {
|
313
|
+
code.push("\nbuffer += renderSection(name,stack,callback,true);");
|
314
|
+
} else {
|
315
|
+
code.push("\nbuffer += renderSection(name,stack,callback);");
|
316
|
+
}
|
317
|
+
|
318
|
+
code.push('\nbuffer += "');
|
319
|
+
};
|
320
|
+
|
321
|
+
var sendPlain = function (source) {
|
322
|
+
code.push(
|
323
|
+
'";',
|
324
|
+
updateLine,
|
325
|
+
'\nbuffer += lookup("' + trim(source) + '",stack,"");',
|
326
|
+
'\nbuffer += "'
|
327
|
+
);
|
328
|
+
};
|
329
|
+
|
330
|
+
var sendEscaped = function (source) {
|
331
|
+
code.push(
|
332
|
+
'";',
|
333
|
+
updateLine,
|
334
|
+
'\nbuffer += escapeHTML(lookup("' + trim(source) + '",stack,""));',
|
335
|
+
'\nbuffer += "'
|
336
|
+
);
|
337
|
+
};
|
338
|
+
|
339
|
+
var line = 1, c, callback;
|
340
|
+
for (var i = 0, len = template.length; i < len; ++i) {
|
341
|
+
if (template.slice(i, i + openTag.length) === openTag) {
|
342
|
+
i += openTag.length;
|
343
|
+
c = template.substr(i, 1);
|
344
|
+
updateLine = '\nline = ' + line + ';';
|
345
|
+
nextOpenTag = openTag;
|
346
|
+
nextCloseTag = closeTag;
|
347
|
+
hasTag = true;
|
348
|
+
|
349
|
+
switch (c) {
|
350
|
+
case "!": // comment
|
351
|
+
i++;
|
352
|
+
callback = null;
|
353
|
+
break;
|
354
|
+
case "=": // change open/close tags, e.g. {{=<% %>=}}
|
355
|
+
i++;
|
356
|
+
closeTag = "=" + closeTag;
|
357
|
+
callback = setTags;
|
358
|
+
break;
|
359
|
+
case ">": // include partial
|
360
|
+
i++;
|
361
|
+
callback = includePartial;
|
362
|
+
break;
|
363
|
+
case "#": // start section
|
364
|
+
i++;
|
365
|
+
callback = openSection;
|
366
|
+
break;
|
367
|
+
case "^": // start inverted section
|
368
|
+
i++;
|
369
|
+
callback = openInvertedSection;
|
370
|
+
break;
|
371
|
+
case "/": // end section
|
372
|
+
i++;
|
373
|
+
callback = closeSection;
|
374
|
+
break;
|
375
|
+
case "{": // plain variable
|
376
|
+
closeTag = "}" + closeTag;
|
377
|
+
// fall through
|
378
|
+
case "&": // plain variable
|
379
|
+
i++;
|
380
|
+
nonSpace = true;
|
381
|
+
callback = sendPlain;
|
382
|
+
break;
|
383
|
+
default: // escaped variable
|
384
|
+
nonSpace = true;
|
385
|
+
callback = sendEscaped;
|
386
|
+
}
|
387
|
+
|
388
|
+
var end = template.indexOf(closeTag, i);
|
389
|
+
|
390
|
+
if (end === -1) {
|
391
|
+
throw debug(new Error('Tag "' + openTag + '" was not closed properly'), template, line, options.file);
|
392
|
+
}
|
393
|
+
|
394
|
+
var source = template.substring(i, end);
|
395
|
+
|
396
|
+
if (callback) {
|
397
|
+
callback(source);
|
398
|
+
}
|
399
|
+
|
400
|
+
// Maintain line count for \n in source.
|
401
|
+
var n = 0;
|
402
|
+
while (~(n = source.indexOf("\n", n))) {
|
403
|
+
line++;
|
404
|
+
n++;
|
405
|
+
}
|
406
|
+
|
407
|
+
i = end + closeTag.length - 1;
|
408
|
+
openTag = nextOpenTag;
|
409
|
+
closeTag = nextCloseTag;
|
410
|
+
} else {
|
411
|
+
c = template.substr(i, 1);
|
412
|
+
|
413
|
+
switch (c) {
|
414
|
+
case '"':
|
415
|
+
case "\\":
|
416
|
+
nonSpace = true;
|
417
|
+
code.push("\\" + c);
|
418
|
+
break;
|
419
|
+
case "\r":
|
420
|
+
// Ignore carriage returns.
|
421
|
+
break;
|
422
|
+
case "\n":
|
423
|
+
spaces.push(code.length);
|
424
|
+
code.push("\\n");
|
425
|
+
stripSpace(); // Check for whitespace on the current line.
|
426
|
+
line++;
|
427
|
+
break;
|
428
|
+
default:
|
429
|
+
if (isWhitespace(c)) {
|
430
|
+
spaces.push(code.length);
|
431
|
+
} else {
|
432
|
+
nonSpace = true;
|
433
|
+
}
|
434
|
+
|
435
|
+
code.push(c);
|
436
|
+
}
|
437
|
+
}
|
438
|
+
}
|
439
|
+
|
440
|
+
if (sectionStack.length != 0) {
|
441
|
+
throw debug(new Error('Section "' + sectionStack[sectionStack.length - 1].name + '" was not closed properly'), template, line, options.file);
|
442
|
+
}
|
443
|
+
|
444
|
+
// Clean up any whitespace from a closing {{tag}} that was at the end
|
445
|
+
// of the template without a trailing \n.
|
446
|
+
stripSpace();
|
447
|
+
|
448
|
+
code.push(
|
449
|
+
'";',
|
450
|
+
"\nreturn buffer;",
|
451
|
+
"\n} catch (e) { throw {error: e, line: line}; }"
|
452
|
+
);
|
453
|
+
|
454
|
+
// Ignore `buffer += "";` statements.
|
455
|
+
var body = code.join("").replace(/buffer \+= "";\n/g, "");
|
456
|
+
|
457
|
+
if (options.debug) {
|
458
|
+
if (typeof console != "undefined" && console.log) {
|
459
|
+
console.log(body);
|
460
|
+
} else if (typeof print === "function") {
|
461
|
+
print(body);
|
462
|
+
}
|
463
|
+
}
|
464
|
+
|
465
|
+
return body;
|
466
|
+
}
|
467
|
+
|
468
|
+
/**
|
469
|
+
* Used by `compile` to generate a reusable function for the given `template`.
|
470
|
+
*/
|
471
|
+
function _compile(template, options) {
|
472
|
+
var args = "view,partials,stack,lookup,escapeHTML,renderSection,render";
|
473
|
+
var body = parse(template, options);
|
474
|
+
var fn = new Function(args, body);
|
475
|
+
|
476
|
+
// This anonymous function wraps the generated function so we can do
|
477
|
+
// argument coercion, setup some variables, and handle any errors
|
478
|
+
// encountered while executing it.
|
479
|
+
return function (view, partials) {
|
480
|
+
partials = partials || {};
|
481
|
+
|
482
|
+
var stack = [view]; // context stack
|
483
|
+
|
484
|
+
try {
|
485
|
+
return fn(view, partials, stack, lookup, escapeHTML, renderSection, render);
|
486
|
+
} catch (e) {
|
487
|
+
throw debug(e.error, template, e.line, options.file);
|
488
|
+
}
|
489
|
+
};
|
490
|
+
}
|
491
|
+
|
492
|
+
// Cache of pre-compiled templates.
|
493
|
+
var _cache = {};
|
494
|
+
|
495
|
+
/**
|
496
|
+
* Clear the cache of compiled templates.
|
497
|
+
*/
|
498
|
+
function clearCache() {
|
499
|
+
_cache = {};
|
500
|
+
}
|
501
|
+
|
502
|
+
/**
|
503
|
+
* Compiles the given `template` into a reusable function using the given
|
504
|
+
* `options`. In addition to the options accepted by Mustache.parse,
|
505
|
+
* recognized options include the following:
|
506
|
+
*
|
507
|
+
* - cache Set `false` to bypass any pre-compiled version of the given
|
508
|
+
* template. Otherwise, a given `template` string will be cached
|
509
|
+
* the first time it is parsed
|
510
|
+
*/
|
511
|
+
function compile(template, options) {
|
512
|
+
options = options || {};
|
513
|
+
|
514
|
+
// Use a pre-compiled version from the cache if we have one.
|
515
|
+
if (options.cache !== false) {
|
516
|
+
if (!_cache[template]) {
|
517
|
+
_cache[template] = _compile(template, options);
|
518
|
+
}
|
519
|
+
|
520
|
+
return _cache[template];
|
521
|
+
}
|
522
|
+
|
523
|
+
return _compile(template, options);
|
524
|
+
}
|
525
|
+
|
526
|
+
/**
|
527
|
+
* High-level function that renders the given `template` using the given
|
528
|
+
* `view` and `partials`. If you need to use any of the template options (see
|
529
|
+
* `compile` above), you must compile in a separate step, and then call that
|
530
|
+
* compiled function.
|
531
|
+
*/
|
532
|
+
function render(template, view, partials) {
|
533
|
+
return compile(template)(view, partials);
|
534
|
+
}
|
535
|
+
|
536
|
+
})(Mustache);
|