http://git-wip-us.apache.org/repos/asf/ambari/blob/cd6398a1/contrib/views/storm/src/main/resources/libs/bower/require-handlebars-plugin/js/hbs.js ---------------------------------------------------------------------- diff --git a/contrib/views/storm/src/main/resources/libs/bower/require-handlebars-plugin/js/hbs.js b/contrib/views/storm/src/main/resources/libs/bower/require-handlebars-plugin/js/hbs.js new file mode 100644 index 0000000..6ecf034 --- /dev/null +++ b/contrib/views/storm/src/main/resources/libs/bower/require-handlebars-plugin/js/hbs.js @@ -0,0 +1,492 @@ +/** + * @license Handlebars hbs 0.4.0 - Alex Sexton, but Handlebars has it's own licensing junk + * + * Available via the MIT or new BSD license. + * see: http://github.com/jrburke/require-cs for details on the plugin this was based off of + */ + +/* Yes, deliciously evil. */ +/*jslint evil: true, strict: false, plusplus: false, regexp: false */ +/*global require: false, XMLHttpRequest: false, ActiveXObject: false, +define: false, process: false, window: false */ +define([ +//>>excludeStart('excludeHbs', pragmas.excludeHbs) +'handlebars', 'underscore', 'i18nprecompile', 'json2' +//>>excludeEnd('excludeHbs') +], function ( +//>>excludeStart('excludeHbs', pragmas.excludeHbs) + Handlebars, _, precompile, JSON +//>>excludeEnd('excludeHbs') +) { +//>>excludeStart('excludeHbs', pragmas.excludeHbs) + var fs, getXhr, + progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'], + fetchText = function () { + throw new Error('Environment unsupported.'); + }, + buildMap = [], + filecode = "w+", + templateExtension = "hbs", + customNameExtension = "@hbs", + devStyleDirectory = "/styles/", + buildStyleDirectory = "/demo-build/styles/", + helperDirectory = "template/helpers/", + i18nDirectory = "template/i18n/", + buildCSSFileName = "screen.build.css"; + + Handlebars.registerHelper('$', function() { + //placeholder for translation helper + }); + + if (typeof window !== "undefined" && window.navigator && window.document && !window.navigator.userAgent.match(/Node.js/)) { + // Browser action + getXhr = function () { + //Would love to dump the ActiveX crap in here. Need IE 6 to die first. + var xhr, i, progId; + if (typeof XMLHttpRequest !== "undefined") { + return new XMLHttpRequest(); + } else { + for (i = 0; i < 3; i++) { + progId = progIds[i]; + try { + xhr = new ActiveXObject(progId); + } catch (e) {} + + if (xhr) { + progIds = [progId]; // so faster next time + break; + } + } + } + + if (!xhr) { + throw new Error("getXhr(): XMLHttpRequest not available"); + } + + return xhr; + }; + + fetchText = function (url, callback) { + var prependComment = "<!--START: "+url+"--> == <!--END: "+url+"-->"; + var xhr = getXhr(); + xhr.open('GET', url, true); + xhr.onreadystatechange = function (evt) { + //Do not explicitly handle errors, those should be + //visible via console output in the browser. + if (xhr.readyState === 4) { + callback(xhr.responseText); + //TODO FIXME Gautam:Not working with backbone-forms when it does this : $($.trim(this.template(_.result(this, 'templateData')))); + // callback(prependComment.replace('==',xhr.responseText)); + } + }; + xhr.send(null); + }; + + } else if (typeof process !== "undefined" && + process.versions && + !!process.versions.node) { + //Using special require.nodeRequire, something added by r.js. + fs = require.nodeRequire('fs'); + fetchText = function ( path, callback ) { + var body = fs.readFileSync(path, 'utf8') || ""; + // we need to remove BOM stuff from the file content + body = body.replace(/^\uFEFF/, ''); + callback(body); + }; + } else if (typeof java !== "undefined" && typeof java.io !== "undefined") { + fetchText = function(path, callback) { + var f = new java.io.File(path); + var is = new java.io.FileReader(f); + var reader = new java.io.BufferedReader(is); + var line; + var text = ""; + while ((line = reader.readLine()) !== null) { + text += new String(line) + "\n"; + } + reader.close(); + callback(text); + }; + } + + var cache = {}; + var fetchOrGetCached = function ( path, callback ){ + if ( cache[path] ){ + callback(cache[path]); + } + else { + fetchText(path, function(data){ + cache[path] = data; + callback.call(this, data); + }); + } + }; + var styleList = [], styleMap = {}; +//>>excludeEnd('excludeHbs') + + return { + + get: function () { + return Handlebars; + }, + + write: function (pluginName, name, write) { + + if ( (name + customNameExtension ) in buildMap) { + var text = buildMap[name + customNameExtension]; + write.asModule(pluginName + "!" + name, text); + } + }, + + version: '0.4.0', + + load: function (name, parentRequire, load, config) { + //>>excludeStart('excludeHbs', pragmas.excludeHbs) + + var compiledName = name + customNameExtension, + disableI18n = (config.hbs && config.hbs.disableI18n), + partialDeps = []; + + function recursiveNodeSearch( statements, res ) { + _(statements).forEach(function ( statement ) { + if ( statement && statement.type && statement.type === 'partial' ) { + res.push(statement.partialName.name); + } + if ( statement && statement.program && statement.program.statements ) { + recursiveNodeSearch( statement.program.statements, res ); + } + if ( statement && statement.program && statement.program.inverse && statement.program.inverse.statements ) { + recursiveNodeSearch( statement.program.inverse.statements, res ); + } + }); + return res; + } + + // TODO :: use the parser to do this! + function findPartialDeps( nodes ) { + var res = []; + if ( nodes && nodes.statements ) { + res = recursiveNodeSearch( nodes.statements, [] ); + } + return _(res).unique(); + } + + // See if the first item is a comment that's json + function getMetaData( nodes ) { + var statement, res, test; + if ( nodes && nodes.statements ) { + statement = nodes.statements[0]; + if ( statement && statement.type === "comment" ) { + try { + res = ( statement.comment ).replace(new RegExp('^[\\s]+|[\\s]+$', 'g'), ''); + test = JSON.parse(res); + return res; + } + catch (e) { + return "{}"; + } + } + } + return "{}"; + } + function composeParts ( parts ) { + if ( !parts ) { + return []; + } + var res = [parts[0]], + cur = parts[0], + i; + + for (i = 1; i < parts.length; ++i) { + if ( parts.hasOwnProperty(i) ) { + cur += "." + parts[i]; + res.push( cur ); + } + } + return res; + } + + function recursiveVarSearch( statements, res, prefix, helpersres ) { + prefix = prefix ? prefix+"." : ""; + + var newprefix = "", flag = false; + + // loop through each statement + _(statements).forEach(function ( statement ) { + var parts, part, sideways; + + // if it's a mustache block + if ( statement && statement.type && statement.type === 'mustache' ) { + + // If it has params, the first part is a helper or something + if ( !statement.params || ! statement.params.length ) { + parts = composeParts( statement.id.parts ); + for( part in parts ) { + if ( parts[ part ] ) { + newprefix = parts[ part ] || newprefix; + res.push( prefix + parts[ part ] ); + } + } + res.push(prefix + statement.id.string); + } + + var paramsWithoutParts = ['this', '.', '..', './..', '../..', '../../..']; + + // grab the params + if ( statement.params && typeof Handlebars.helpers[statement.id.string] === 'undefined') { + _(statement.params).forEach(function(param) { + if ( _(paramsWithoutParts).contains(param.original) + || param instanceof Handlebars.AST.StringNode + || param instanceof Handlebars.AST.IntegerNode + || param instanceof Handlebars.AST.BooleanNode + ) { + helpersres.push(statement.id.string); + } + + parts = composeParts( param.parts ); + + for(var part in parts ) { + if ( parts[ part ] ) { + newprefix = parts[part] || newprefix; + helpersres.push(statement.id.string); + res.push( prefix + parts[ part ] ); + } + } + }); + } + } + + // If it's a meta block + if ( statement && statement.mustache ) { + recursiveVarSearch( [statement.mustache], res, prefix + newprefix, helpersres ); + } + + // if it's a whole new program + if ( statement && statement.program && statement.program.statements ) { + sideways = recursiveVarSearch([statement.mustache],[], "", helpersres)[0] || ""; + if ( statement.program.inverse && statement.program.inverse.statements ) { + recursiveVarSearch( statement.program.inverse.statements, res, prefix + newprefix + (sideways ? (prefix+newprefix) ? "."+sideways : sideways : ""), helpersres); + } + recursiveVarSearch( statement.program.statements, res, prefix + newprefix + (sideways ? (prefix+newprefix) ? "."+sideways : sideways : ""), helpersres); + } + }); + return res; + } + + // This finds the Helper dependencies since it's soooo similar + function getExternalDeps( nodes ) { + var res = []; + var helpersres = []; + + if ( nodes && nodes.statements ) { + res = recursiveVarSearch( nodes.statements, [], undefined, helpersres ); + } + + var defaultHelpers = ["helperMissing", "blockHelperMissing", "each", "if", "unless", "with"]; + + return { + vars : _(res).chain().unique().map(function(e){ + if ( e === "" ) { + return '.'; + } + if ( e.length && e[e.length-1] === '.' ) { + return e.substr(0,e.length-1) + '[]'; + } + return e; + }).value(), + helpers : _(helpersres).chain().unique().map(function(e){ + if ( _(defaultHelpers).contains(e) ) { + return undefined; + } + return e; + }).compact().value() + }; + } + + function fetchAndRegister(langMap){ + fetchText(path, function (text) { + // for some reason it doesn't include hbs _first_ when i don't add it here... + var nodes = Handlebars.parse(text), + deps = findPartialDeps( nodes ), + meta = getMetaData( nodes ), + extDeps = getExternalDeps( nodes ), + vars = extDeps.vars, + helps = extDeps.helpers || [], + depStr = deps.join("', 'hbs!").replace(/_/g, '/'), + helpDepStr = config.hbs && config.hbs.disableHelpers ? + "" : (function (){ + var i, paths = [], + pathGetter = config.hbs && config.hbs.helperPathCallback + ? config.hbs.helperPathCallback + : function (name){return (config.hbs && config.hbs.helperDirectory ? config.hbs.helperDirectory : helperDirectory) + name;}; + + for ( i = 0; i < helps.length; i++ ) { + paths[i] = "'" + pathGetter(helps[i], path) + "'" + } + return paths; + })().join(','), + debugOutputStart = "", + debugOutputEnd = "", + debugProperties = "", + metaObj, head, linkElem; + + if ( depStr ) { + depStr = ",'hbs!" + depStr + "'"; + } + if ( helpDepStr ) { + helpDepStr = "," + helpDepStr; + } + + if ( meta !== "{}" ) { + try { + metaObj = JSON.parse(meta); + if ( metaObj && metaObj.styles ) { + styleList = _.union(styleList, metaObj.styles); + + // In dev mode in the browser + if ( require.isBrowser && ! config.isBuild ) { + head = document.head || document.getElementsByTagName('head')[0]; + _(metaObj.styles).forEach(function (style) { + if ( !styleMap[style] ) { + linkElem = document.createElement('link'); + linkElem.href = config.baseUrl + devStyleDirectory + style + '.css'; + linkElem.media = 'all'; + linkElem.rel = 'stylesheet'; + linkElem.type = 'text/css'; + head.appendChild(linkElem); + styleMap[style] = linkElem; + } + }); + } + else if ( config.isBuild ) { + (function(){ + var fs = require.nodeRequire('fs'), + str = _(metaObj.styles).map(function (style) { + if (!styleMap[style]) { + styleMap[style] = true; + return "@import url("+style+".css);\n"; + } + return ""; + }).join("\n"); + + // I write out my import statements to a file in order to help me build stuff. + // Then I use a tool to inline my import statements afterwards. (you can run r.js on it too) + fs.open(__dirname + buildStyleDirectory + buildCSSFileName, filecode, '0666', function( e, id ) { + fs.writeSync(id, str, null, encoding='utf8'); + fs.close(id); + }); + filecode = "a"; + })(); + } + } + } + catch(e){ + console.log('error injecting styles'); + } + } + + if ( ! config.isBuild && ! config.serverRender ) { + debugOutputStart = "<!-- START - " + name + " -->"; + debugOutputEnd = "<!-- END - " + name + " -->"; + debugProperties = "t.meta = " + meta + ";\n" + + "t.helpers = " + JSON.stringify(helps) + ";\n" + + "t.deps = " + JSON.stringify(deps) + ";\n" + + "t.vars = " + JSON.stringify(vars) + ";\n"; + } + + var mapping = disableI18n? false : _.extend( langMap, config.localeMapping ), + configHbs = config.hbs || {}, + options = _.extend(configHbs.compileOptions || {}, { originalKeyFallback: configHbs.originalKeyFallback }), + prec = precompile( text, mapping, options); + + text = "/* START_TEMPLATE */\n" + + "define(['hbs','handlebars'"+depStr+helpDepStr+"], function( hbs, Handlebars ){ \n" + + "var t = Handlebars.template(" + prec + ");\n" + + "Handlebars.registerPartial('" + name.replace( /\//g , '_') + "', t);\n" + + debugProperties + + "return t;\n" + + "});\n" + + "/* END_TEMPLATE */\n"; + + //Hold on to the transformed text if a build. + if (config.isBuild) { + buildMap[compiledName] = text; + } + + //IE with conditional comments on cannot handle the + //sourceURL trick, so skip it if enabled. + /*@if (@_jscript) @else @*/ + if (!config.isBuild) { + text += "\r\n//@ sourceURL=" + path; + } + /*@end@*/ + + for ( var i in deps ) { + if ( deps.hasOwnProperty(i) ) { + deps[ i ] = 'hbs!' + deps[ i ].replace(/_/g, '/'); + } + } + + if ( !config.isBuild ) { + require( deps, function (){ + load.fromText(text); + + //Give result to load. Need to wait until the module + //is fully parse, which will happen after this + //execution. + parentRequire([name], function (value) { + load(value); + }); + }); + } + else { + load.fromText(name, text); + + //Give result to load. Need to wait until the module + //is fully parse, which will happen after this + //execution. + parentRequire([name], function (value) { + load(value); + }); + } + + if ( config.removeCombined ) { + fs.unlinkSync(path); + } + }); + } + + var path, + omitExtension = config.hbs && config.hbs.templateExtension === false; + if(omitExtension) { + path = parentRequire.toUrl(name); + } else { + path = parentRequire.toUrl(name +'.'+ (config.hbs && config.hbs.templateExtension ? config.hbs.templateExtension : templateExtension)); + } + + if (disableI18n){ + fetchAndRegister(false); + } else { + // Workaround until jam is able to pass config info or we move i18n to a separate module. + // This logs a warning and disables i18n if there's an error loading the language file + var langMapPath = (config.hbs && config.hbs.i18nDirectory ? config.hbs.i18nDirectory : i18nDirectory) + (config.locale || "en_us") + '.json'; + try { + fetchOrGetCached(parentRequire.toUrl(langMapPath), function (langMap) { + fetchAndRegister(JSON.parse(langMap)); + }); + } catch(er) { + // if there's no configuration at all, log a warning and disable i18n for this and subsequent templates + if(!config.hbs) { + console.warn('hbs: Error reading ' + langMapPath + ', disabling i18n. Ignore this if you\'re using jam, otherwise check your i18n configuration.\n'); + config.hbs = {disableI18n: true}; + fetchAndRegister(false); + } else { + throw er; + + } + } + } + //>>excludeEnd('excludeHbs') + } + }; +}); +/* END_hbs_PLUGIN */
http://git-wip-us.apache.org/repos/asf/ambari/blob/cd6398a1/contrib/views/storm/src/main/resources/libs/bower/require-handlebars-plugin/js/i18nprecompile.js ---------------------------------------------------------------------- diff --git a/contrib/views/storm/src/main/resources/libs/bower/require-handlebars-plugin/js/i18nprecompile.js b/contrib/views/storm/src/main/resources/libs/bower/require-handlebars-plugin/js/i18nprecompile.js new file mode 100644 index 0000000..f012e64 --- /dev/null +++ b/contrib/views/storm/src/main/resources/libs/bower/require-handlebars-plugin/js/i18nprecompile.js @@ -0,0 +1,57 @@ +//>>excludeStart('excludeAfterBuild', pragmas.excludeAfterBuild) +define(['handlebars', "underscore"], function ( Handlebars, _ ) { + + function replaceLocaleStrings ( ast, mapping, options ) { + options = options || {}; + mapping = mapping || {}; + // Base set of things + if ( ast && ast.type === "program" && ast.statements ) { + _(ast.statements).forEach(function(statement, i){ + var newString = "<!-- i18n error -->"; + // If it's a translation node + if ( statement.type === "mustache" && statement.id && statement.id.original === "$" ) { + + if ( statement.params.length && statement.params[0].string ) { + var key = statement.params[0].string; + newString = mapping[ key ] || (options.originalKeyFallback ? key : newString); + } + ast.statements[i] = new Handlebars.AST.ContentNode(newString); + } + // If we need to recurse + else if ( statement.program ) { + statement.program = replaceLocaleStrings( statement.program, mapping, options ); + } + }); + // Also cover the else blocks + if (ast.inverse) { + replaceLocaleStrings(ast.inverse, mapping, options); + } + } + return ast; + } + + return function precompile (string, mapping, options) { + var ast, environment; + + options = options || {}; + + if (!('data' in options)) { + options.data = true; + } + + if (options.compat) { + options.useDepths = true; + } + + ast = Handlebars.parse(string); + + // avoid replacing locale if mapping is `false` + if (mapping !== false) { + ast = replaceLocaleStrings(ast, mapping, options); + } + + environment = new Handlebars.Compiler().compile(ast, options); + return new Handlebars.JavaScriptCompiler().compile(environment, options); + }; +}); +//>>excludeEnd('excludeAfterBuild') http://git-wip-us.apache.org/repos/asf/ambari/blob/cd6398a1/contrib/views/storm/src/main/resources/libs/bower/require-handlebars-plugin/js/json2.js ---------------------------------------------------------------------- diff --git a/contrib/views/storm/src/main/resources/libs/bower/require-handlebars-plugin/js/json2.js b/contrib/views/storm/src/main/resources/libs/bower/require-handlebars-plugin/js/json2.js new file mode 100644 index 0000000..cf215d8 --- /dev/null +++ b/contrib/views/storm/src/main/resources/libs/bower/require-handlebars-plugin/js/json2.js @@ -0,0 +1,365 @@ +//>>excludeStart('excludeAfterBuild', pragmas.excludeAfterBuild) +/* + http://www.JSON.org/json2.js + 2011-10-19 + + Public Domain. + + NO WARRANTY EXPRESSED OR IMPLIED. USE AT YOUR OWN RISK. + + See http://www.JSON.org/js.html + + + This code should be minified before deployment. + See http://javascript.crockford.com/jsmin.html + + USE YOUR OWN COPY. IT IS EXTREMELY UNWISE TO LOAD CODE FROM SERVERS YOU DO + NOT CONTROL. +*/ + +/*jslint evil: true, regexp: true */ + +/*members "", "\b", "\t", "\n", "\f", "\r", "\"", JSON, "\\", apply, + call, charCodeAt, getUTCDate, getUTCFullYear, getUTCHours, + getUTCMinutes, getUTCMonth, getUTCSeconds, hasOwnProperty, join, + lastIndex, length, parse, prototype, push, replace, slice, stringify, + test, toJSON, toString, valueOf +*/ + +(function (window){ + +// Create a JSON object only if one does not already exist. We create the +// methods in a closure to avoid creating global variables. + +// Return the window JSON element if it exists; +var JSON = window.JSON || {}; + +(function () { + 'use strict'; + + function f(n) { + // Format integers to have at least two digits. + return n < 10 ? '0' + n : n; + } + + if (typeof Date.prototype.toJSON !== 'function') { + + Date.prototype.toJSON = function (key) { + + return isFinite(this.valueOf()) + ? this.getUTCFullYear() + '-' + + f(this.getUTCMonth() + 1) + '-' + + f(this.getUTCDate()) + 'T' + + f(this.getUTCHours()) + ':' + + f(this.getUTCMinutes()) + ':' + + f(this.getUTCSeconds()) + 'Z' + : null; + }; + + String.prototype.toJSON = + Number.prototype.toJSON = + Boolean.prototype.toJSON = function (key) { + return this.valueOf(); + }; + } + + var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, + escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, + gap, + indent, + meta = { // table of character substitutions + '\b': '\\b', + '\t': '\\t', + '\n': '\\n', + '\f': '\\f', + '\r': '\\r', + '"' : '\\"', + '\\': '\\\\' + }, + rep; + + + function quote(string) { + +// If the string contains no control characters, no quote characters, and no +// backslash characters, then we can safely slap some quotes around it. +// Otherwise we must also replace the offending characters with safe escape +// sequences. + + escapable.lastIndex = 0; + return escapable.test(string) ? '"' + string.replace(escapable, function (a) { + var c = meta[a]; + return typeof c === 'string' + ? c + : '\\u' + ('0000' + a.charCodeAt(0).toString(16)).slice(-4); + }) + '"' : '"' + string + '"'; + } + + + function str(key, holder) { + +// Produce a string from holder[key]. + + var i, // The loop counter. + k, // The member key. + v, // The member value. + length, + mind = gap, + partial, + value = holder[key]; + +// If the value has a toJSON method, call it to obtain a replacement value. + + if (value && typeof value === 'object' && + typeof value.toJSON === 'function') { + value = value.toJSON(key); + } + +// If we were called with a replacer function, then call the replacer to +// obtain a replacement value. + + if (typeof rep === 'function') { + value = rep.call(holder, key, value); + } + +// What happens next depends on the value's type. + + switch (typeof value) { + case 'string': + return quote(value); + + case 'number': + +// JSON numbers must be finite. Encode non-finite numbers as null. + + return isFinite(value) ? String(value) : 'null'; + + case 'boolean': + case 'null': + +// If the value is a boolean or null, convert it to a string. Note: +// typeof null does not produce 'null'. The case is included here in +// the remote chance that this gets fixed someday. + + return String(value); + +// If the type is 'object', we might be dealing with an object or an array or +// null. + + case 'object': + +// Due to a specification blunder in ECMAScript, typeof null is 'object', +// so watch out for that case. + + if (!value) { + return 'null'; + } + +// Make an array to hold the partial results of stringifying this object value. + + gap += indent; + partial = []; + +// Is the value an array? + + if (Object.prototype.toString.apply(value) === '[object Array]') { + +// The value is an array. Stringify every element. Use null as a placeholder +// for non-JSON values. + + length = value.length; + for (i = 0; i < length; i += 1) { + partial[i] = str(i, value) || 'null'; + } + +// Join all of the elements together, separated with commas, and wrap them in +// brackets. + + v = partial.length === 0 + ? '[]' + : gap + ? '[\n' + gap + partial.join(',\n' + gap) + '\n' + mind + ']' + : '[' + partial.join(',') + ']'; + gap = mind; + return v; + } + +// If the replacer is an array, use it to select the members to be stringified. + + if (rep && typeof rep === 'object') { + length = rep.length; + for (i = 0; i < length; i += 1) { + if (typeof rep[i] === 'string') { + k = rep[i]; + v = str(k, value); + if (v) { + partial.push(quote(k) + (gap ? ': ' : ':') + v); + } + } + } + } else { + +// Otherwise, iterate through all of the keys in the object. + + for (k in value) { + if (Object.prototype.hasOwnProperty.call(value, k)) { + v = str(k, value); + if (v) { + partial.push(quote(k) + (gap ? ': ' : ':') + v); + } + } + } + } + +// Join all of the member texts together, separated with commas, +// and wrap them in braces. + + v = partial.length === 0 + ? '{}' + : gap + ? '{\n' + gap + partial.join(',\n' + gap) + '\n' + mind + '}' + : '{' + partial.join(',') + '}'; + gap = mind; + return v; + } + } + +// If the JSON object does not yet have a stringify method, give it one. + + if (typeof JSON.stringify !== 'function') { + JSON.stringify = function (value, replacer, space) { + +// The stringify method takes a value and an optional replacer, and an optional +// space parameter, and returns a JSON text. The replacer can be a function +// that can replace values, or an array of strings that will select the keys. +// A default replacer method can be provided. Use of the space parameter can +// produce text that is more easily readable. + + var i; + gap = ''; + indent = ''; + +// If the space parameter is a number, make an indent string containing that +// many spaces. + + if (typeof space === 'number') { + for (i = 0; i < space; i += 1) { + indent += ' '; + } + +// If the space parameter is a string, it will be used as the indent string. + + } else if (typeof space === 'string') { + indent = space; + } + +// If there is a replacer, it must be a function or an array. +// Otherwise, throw an error. + + rep = replacer; + if (replacer && typeof replacer !== 'function' && + (typeof replacer !== 'object' || + typeof replacer.length !== 'number')) { + throw new Error('JSON.stringify'); + } + +// Make a fake root object containing our value under the key of ''. +// Return the result of stringifying the value. + + return str('', {'': value}); + }; + } + + +// If the JSON object does not yet have a parse method, give it one. + + if (typeof JSON.parse !== 'function') { + JSON.parse = function (text, reviver) { + +// The parse method takes a text and an optional reviver function, and returns +// a JavaScript value if the text is a valid JSON text. + + var j; + + function walk(holder, key) { + +// The walk method is used to recursively walk the resulting structure so +// that modifications can be made. + + var k, v, value = holder[key]; + if (value && typeof value === 'object') { + for (k in value) { + if (Object.prototype.hasOwnProperty.call(value, k)) { + v = walk(value, k); + if (v !== undefined) { + value[k] = v; + } else { + delete value[k]; + } + } + } + } + return reviver.call(holder, key, value); + } + + +// Parsing happens in four stages. In the first stage, we replace certain +// Unicode characters with escape sequences. JavaScript handles many characters +// incorrectly, either silently deleting them, or treating them as line endings. + + text = String(text); + cx.lastIndex = 0; + if (cx.test(text)) { + text = text.replace(cx, function (a) { + return '\\u' + + ('0000' + a.charCodeAt(0).toString(16)).slice(-4); + }); + } + +// In the second stage, we run the text against regular expressions that look +// for non-JSON patterns. We are especially concerned with '()' and 'new' +// because they can cause invocation, and '=' because it can cause mutation. +// But just to be safe, we want to reject all unexpected forms. + +// We split the second stage into 4 regexp operations in order to work around +// crippling inefficiencies in IE's and Safari's regexp engines. First we +// replace the JSON backslash pairs with '@' (a non-JSON character). Second, we +// replace all simple value tokens with ']' characters. Third, we delete all +// open brackets that follow a colon or comma or that begin the text. Finally, +// we look to see that the remaining characters are only whitespace or ']' or +// ',' or ':' or '{' or '}'. If that is so, then the text is safe for eval. + + if (/^[\],:{}\s]*$/ + .test(text.replace(/\\(?:["\\\/bfnrt]|u[0-9a-fA-F]{4})/g, '@') + .replace(/"[^"\\\n\r]*"|true|false|null|-?\d+(?:\.\d*)?(?:[eE][+\-]?\d+)?/g, ']') + .replace(/(?:^|:|,)(?:\s*\[)+/g, ''))) { + +// In the third stage we use the eval function to compile the text into a +// JavaScript structure. The '{' operator is subject to a syntactic ambiguity +// in JavaScript: it can begin a block or an object literal. We wrap the text +// in parens to eliminate the ambiguity. + + j = eval('(' + text + ')'); + +// In the optional fourth stage, we recursively walk the new structure, passing +// each name/value pair to a reviver function for possible transformation. + + return typeof reviver === 'function' + ? walk({'': j}, '') + : j; + } + +// If the text is not JSON parseable, then a SyntaxError is thrown. + + throw new SyntaxError('JSON.parse'); + }; + } +}()); + +define(function(){ + return JSON; +}); +// otherwise just leave it alone + +}).call(this, this); +//>>excludeEnd('excludeAfterBuild') http://git-wip-us.apache.org/repos/asf/ambari/blob/cd6398a1/contrib/views/storm/src/main/resources/libs/bower/requirejs-text/js/text.js ---------------------------------------------------------------------- diff --git a/contrib/views/storm/src/main/resources/libs/bower/requirejs-text/js/text.js b/contrib/views/storm/src/main/resources/libs/bower/requirejs-text/js/text.js new file mode 100644 index 0000000..7eed271 --- /dev/null +++ b/contrib/views/storm/src/main/resources/libs/bower/requirejs-text/js/text.js @@ -0,0 +1,390 @@ +/** + * @license RequireJS text 2.0.13 Copyright (c) 2010-2014, The Dojo Foundation All Rights Reserved. + * Available via the MIT or new BSD license. + * see: http://github.com/requirejs/text for details + */ +/*jslint regexp: true */ +/*global require, XMLHttpRequest, ActiveXObject, + define, window, process, Packages, + java, location, Components, FileUtils */ + +define(['module'], function (module) { + 'use strict'; + + var text, fs, Cc, Ci, xpcIsWindows, + progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'], + xmlRegExp = /^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im, + bodyRegExp = /<body[^>]*>\s*([\s\S]+)\s*<\/body>/im, + hasLocation = typeof location !== 'undefined' && location.href, + defaultProtocol = hasLocation && location.protocol && location.protocol.replace(/\:/, ''), + defaultHostName = hasLocation && location.hostname, + defaultPort = hasLocation && (location.port || undefined), + buildMap = {}, + masterConfig = (module.config && module.config()) || {}; + + text = { + version: '2.0.13', + + strip: function (content) { + //Strips <?xml ...?> declarations so that external SVG and XML + //documents can be added to a document without worry. Also, if the string + //is an HTML document, only the part inside the body tag is returned. + if (content) { + content = content.replace(xmlRegExp, ""); + var matches = content.match(bodyRegExp); + if (matches) { + content = matches[1]; + } + } else { + content = ""; + } + return content; + }, + + jsEscape: function (content) { + return content.replace(/(['\\])/g, '\\$1') + .replace(/[\f]/g, "\\f") + .replace(/[\b]/g, "\\b") + .replace(/[\n]/g, "\\n") + .replace(/[\t]/g, "\\t") + .replace(/[\r]/g, "\\r") + .replace(/[\u2028]/g, "\\u2028") + .replace(/[\u2029]/g, "\\u2029"); + }, + + createXhr: masterConfig.createXhr || function () { + //Would love to dump the ActiveX crap in here. Need IE 6 to die first. + var xhr, i, progId; + if (typeof XMLHttpRequest !== "undefined") { + return new XMLHttpRequest(); + } else if (typeof ActiveXObject !== "undefined") { + for (i = 0; i < 3; i += 1) { + progId = progIds[i]; + try { + xhr = new ActiveXObject(progId); + } catch (e) {} + + if (xhr) { + progIds = [progId]; // so faster next time + break; + } + } + } + + return xhr; + }, + + /** + * Parses a resource name into its component parts. Resource names + * look like: module/name.ext!strip, where the !strip part is + * optional. + * @param {String} name the resource name + * @returns {Object} with properties "moduleName", "ext" and "strip" + * where strip is a boolean. + */ + parseName: function (name) { + var modName, ext, temp, + strip = false, + index = name.lastIndexOf("."), + isRelative = name.indexOf('./') === 0 || + name.indexOf('../') === 0; + + if (index !== -1 && (!isRelative || index > 1)) { + modName = name.substring(0, index); + ext = name.substring(index + 1); + } else { + modName = name; + } + + temp = ext || modName; + index = temp.indexOf("!"); + if (index !== -1) { + //Pull off the strip arg. + strip = temp.substring(index + 1) === "strip"; + temp = temp.substring(0, index); + if (ext) { + ext = temp; + } else { + modName = temp; + } + } + + return { + moduleName: modName, + ext: ext, + strip: strip + }; + }, + + xdRegExp: /^((\w+)\:)?\/\/([^\/\\]+)/, + + /** + * Is an URL on another domain. Only works for browser use, returns + * false in non-browser environments. Only used to know if an + * optimized .js version of a text resource should be loaded + * instead. + * @param {String} url + * @returns Boolean + */ + useXhr: function (url, protocol, hostname, port) { + var uProtocol, uHostName, uPort, + match = text.xdRegExp.exec(url); + if (!match) { + return true; + } + uProtocol = match[2]; + uHostName = match[3]; + + uHostName = uHostName.split(':'); + uPort = uHostName[1]; + uHostName = uHostName[0]; + + return (!uProtocol || uProtocol === protocol) && + (!uHostName || uHostName.toLowerCase() === hostname.toLowerCase()) && + ((!uPort && !uHostName) || uPort === port); + }, + + finishLoad: function (name, strip, content, onLoad) { + content = strip ? text.strip(content) : content; + if (masterConfig.isBuild) { + buildMap[name] = content; + } + onLoad(content); + }, + + load: function (name, req, onLoad, config) { + //Name has format: some.module.filext!strip + //The strip part is optional. + //if strip is present, then that means only get the string contents + //inside a body tag in an HTML string. For XML/SVG content it means + //removing the <?xml ...?> declarations so the content can be inserted + //into the current doc without problems. + + // Do not bother with the work if a build and text will + // not be inlined. + if (config && config.isBuild && !config.inlineText) { + onLoad(); + return; + } + + masterConfig.isBuild = config && config.isBuild; + + var parsed = text.parseName(name), + nonStripName = parsed.moduleName + + (parsed.ext ? '.' + parsed.ext : ''), + url = req.toUrl(nonStripName), + useXhr = (masterConfig.useXhr) || + text.useXhr; + + // Do not load if it is an empty: url + if (url.indexOf('empty:') === 0) { + onLoad(); + return; + } + + //Load the text. Use XHR if possible and in a browser. + if (!hasLocation || useXhr(url, defaultProtocol, defaultHostName, defaultPort)) { + text.get(url, function (content) { + text.finishLoad(name, parsed.strip, content, onLoad); + }, function (err) { + if (onLoad.error) { + onLoad.error(err); + } + }); + } else { + //Need to fetch the resource across domains. Assume + //the resource has been optimized into a JS module. Fetch + //by the module name + extension, but do not include the + //!strip part to avoid file system issues. + req([nonStripName], function (content) { + text.finishLoad(parsed.moduleName + '.' + parsed.ext, + parsed.strip, content, onLoad); + }); + } + }, + + write: function (pluginName, moduleName, write, config) { + if (buildMap.hasOwnProperty(moduleName)) { + var content = text.jsEscape(buildMap[moduleName]); + write.asModule(pluginName + "!" + moduleName, + "define(function () { return '" + + content + + "';});\n"); + } + }, + + writeFile: function (pluginName, moduleName, req, write, config) { + var parsed = text.parseName(moduleName), + extPart = parsed.ext ? '.' + parsed.ext : '', + nonStripName = parsed.moduleName + extPart, + //Use a '.js' file name so that it indicates it is a + //script that can be loaded across domains. + fileName = req.toUrl(parsed.moduleName + extPart) + '.js'; + + //Leverage own load() method to load plugin value, but only + //write out values that do not have the strip argument, + //to avoid any potential issues with ! in file names. + text.load(nonStripName, req, function (value) { + //Use own write() method to construct full module value. + //But need to create shell that translates writeFile's + //write() to the right interface. + var textWrite = function (contents) { + return write(fileName, contents); + }; + textWrite.asModule = function (moduleName, contents) { + return write.asModule(moduleName, fileName, contents); + }; + + text.write(pluginName, nonStripName, textWrite, config); + }, config); + } + }; + + if (masterConfig.env === 'node' || (!masterConfig.env && + typeof process !== "undefined" && + process.versions && + !!process.versions.node && + !process.versions['node-webkit'])) { + //Using special require.nodeRequire, something added by r.js. + fs = require.nodeRequire('fs'); + + text.get = function (url, callback, errback) { + try { + var file = fs.readFileSync(url, 'utf8'); + //Remove BOM (Byte Mark Order) from utf8 files if it is there. + if (file[0] === '\uFEFF') { + file = file.substring(1); + } + callback(file); + } catch (e) { + if (errback) { + errback(e); + } + } + }; + } else if (masterConfig.env === 'xhr' || (!masterConfig.env && + text.createXhr())) { + text.get = function (url, callback, errback, headers) { + var xhr = text.createXhr(), header; + xhr.open('GET', url, true); + + //Allow plugins direct access to xhr headers + if (headers) { + for (header in headers) { + if (headers.hasOwnProperty(header)) { + xhr.setRequestHeader(header.toLowerCase(), headers[header]); + } + } + } + + //Allow overrides specified in config + if (masterConfig.onXhr) { + masterConfig.onXhr(xhr, url); + } + + xhr.onreadystatechange = function (evt) { + var status, err; + //Do not explicitly handle errors, those should be + //visible via console output in the browser. + if (xhr.readyState === 4) { + status = xhr.status || 0; + if (status > 399 && status < 600) { + //An http 4xx or 5xx error. Signal an error. + err = new Error(url + ' HTTP status: ' + status); + err.xhr = xhr; + if (errback) { + errback(err); + } + } else { + callback(xhr.responseText); + } + + if (masterConfig.onXhrComplete) { + masterConfig.onXhrComplete(xhr, url); + } + } + }; + xhr.send(null); + }; + } else if (masterConfig.env === 'rhino' || (!masterConfig.env && + typeof Packages !== 'undefined' && typeof java !== 'undefined')) { + //Why Java, why is this so awkward? + text.get = function (url, callback) { + var stringBuffer, line, + encoding = "utf-8", + file = new java.io.File(url), + lineSeparator = java.lang.System.getProperty("line.separator"), + input = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(file), encoding)), + content = ''; + try { + stringBuffer = new java.lang.StringBuffer(); + line = input.readLine(); + + // Byte Order Mark (BOM) - The Unicode Standard, version 3.0, page 324 + // http://www.unicode.org/faq/utf_bom.html + + // Note that when we use utf-8, the BOM should appear as "EF BB BF", but it doesn't due to this bug in the JDK: + // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4508058 + if (line && line.length() && line.charAt(0) === 0xfeff) { + // Eat the BOM, since we've already found the encoding on this file, + // and we plan to concatenating this buffer with others; the BOM should + // only appear at the top of a file. + line = line.substring(1); + } + + if (line !== null) { + stringBuffer.append(line); + } + + while ((line = input.readLine()) !== null) { + stringBuffer.append(lineSeparator); + stringBuffer.append(line); + } + //Make sure we return a JavaScript string and not a Java string. + content = String(stringBuffer.toString()); //String + } finally { + input.close(); + } + callback(content); + }; + } else if (masterConfig.env === 'xpconnect' || (!masterConfig.env && + typeof Components !== 'undefined' && Components.classes && + Components.interfaces)) { + //Avert your gaze! + Cc = Components.classes; + Ci = Components.interfaces; + Components.utils['import']('resource://gre/modules/FileUtils.jsm'); + xpcIsWindows = ('@mozilla.org/windows-registry-key;1' in Cc); + + text.get = function (url, callback) { + var inStream, convertStream, fileObj, + readData = {}; + + if (xpcIsWindows) { + url = url.replace(/\//g, '\\'); + } + + fileObj = new FileUtils.File(url); + + //XPCOM, you so crazy + try { + inStream = Cc['@mozilla.org/network/file-input-stream;1'] + .createInstance(Ci.nsIFileInputStream); + inStream.init(fileObj, 1, 0, false); + + convertStream = Cc['@mozilla.org/intl/converter-input-stream;1'] + .createInstance(Ci.nsIConverterInputStream); + convertStream.init(inStream, "utf-8", inStream.available(), + Ci.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER); + + convertStream.readString(inStream.available(), readData); + convertStream.close(); + inStream.close(); + callback(readData.value); + } catch (e) { + throw new Error((fileObj && fileObj.path || '') + ': ' + e); + } + }; + } + return text; +});
