Skip to content
Snippets Groups Projects
Select Git revision
  • edfecbfac3c311a0649553a32c8284446a894b22
  • master default
  • dev
3 results

text.js

Blame
  • text.js 15.25 KiB
    /**
     * @license RequireJS text 2.0.12 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.12',
    
            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.indexOf("."),
                    isRelative = name.indexOf('./') === 0 ||
                                 name.indexOf('../') === 0;
    
                if (index !== -1 && (!isRelative || index > 1)) {
                    modName = name.substring(0, index);
                    ext = name.substring(index + 1, name.length);
                } 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.indexOf('\uFEFF') === 0) {
                        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;
    });