egret 引擎分析之二————从selector.js说起

前面说了，在控制台执行egret命令其实就是node   /Applications/EgretLauncher.app/Contents/Resources/app/engine/mac/selector.js

所以selector.js里面的js代码就是他做的事情。

/*

 此文件需要放在引擎安装目录
 例如 C:Program FilesEgretEgretEnginewinselector.js
 或   /Applications/EgretEngine.app/Contents/Resources/mac/selector.js

 根据命令行参数
 --ev 2.4.3
 或项目中 egretProperties.json 中指定的引擎版本来执行对应的引擎。

 引擎选择优先级为
 --ev
 egretProperties.json
 默认引擎


 历史版本的引擎位置为：
 Mac: /Users/${user}/Library/Application Support/Egret/engine/${version}/
 Windows: %AppData%/Egret/engine/${version}/
 其中根目录下有 config.json（可选，默认没有） 记录默认引擎和自定义引擎目录
 {
 "egret":{
 "2.0.5":{
 "root":"D:\Work\egret-core\" //自定义目录
 },
 "defaultEngine":"2.4.3"
 }
 }


 默认版本查找顺序
 config.json defaultEngine 指定的版本号
 config.json 中指定的自定义路径
 引擎安装目录/egret
 历史版本根目录/${version}
 EGRET_PATH环境变量仅仅作为兼容以前版本使用



 egret versions 命令输出可用的引擎版本
 Egret Engine 2.4.3  D:/Program Files/Egret/EgretEngine/win/egret/
 Egret Engine 2.0.5  D:/Work/egret-core/


 */
var FS = require("fs");
var Path = require("path");
var selector = require('../egret').selector;
var stat = require('../../stat/egretStat');
var DEFAULT_ENGINE = "defaultEngine";
var args;
var osLocal = require("../os-local.js");
var i18n = osLocal();
i18n = i18n.toLowerCase();
if (i18n == "zh_cn" || i18n == "zh_tw" || i18n == "zh_hk") {
    var language = 'zh';
} else {
    language = 'en'
}

var engines;
var localsMessages = {
    en: {
        1: "Can not find Egret Engine {0}, please install it with Egret Launcher.",
        2: "Can not find Egret Engine, please open Egret Launcher and install.",
        3: "Egret Engine latest version: {0}
Egret Engine current version: {1}
You can upgrade your project via egret upgrade",
        4: "Egret Engine latest version: {0}",
        5: "Error! The egretProperties.json is not a valid json.",
        6: "egret upgrade Need to specify version
usage: egret upgrade --egretversion [target version]
Current upgradeable version:",
        7: "Error! The egretProperties.json have no egret_version.",
        8: "The specified version number must be greater than the version number of the current project, current project version {0}",
        9: "The current project version is already {0}.",
        10: "current project version",
        11: "egret make Need to specify version
usage: egret make --egretversion [target version]"
    },
    zh: {
        1: "未找到 Egret Engine {0} ，请在Egret Launcher中安装该版本引擎",
        2: "尚未安装引擎，请在Egret Launcher中安装该版本引擎",
        3: "您安装的最新引擎版本为 {0}
当前项目使用版本为 {1}
您可以执行 egret upgrade 命令升级项目",
        4: "您安装的最新引擎版本为 {0}",
        5: "错误！！ egretProperties.json 不是有效的 json 文件",
        6: "egret upgrade 需要指定升级版本
usage: egret upgrade --egretversion [target version]
当前可升级版本号：",
        7: "错误！！ egretProperties.json 没有有效的 egret_version",
        8: "指定的版本号必须大于当前项目的版本号，当前项目版本{0}",
        9: "当前项目版本已是{0}，无需升级",
        10: "当前项目版本",
        11: "egret make 需要指定引擎版本
usage: egret make --egretversion [target version]"
    }
};
var commandsToSkip = {
    "upgrade": true
};
function entry() {
    engines = selector.getAllEngineVersions();
    args = parseArgs();
    var requestVersion = args.egretversion || args.ev;
    if (requestVersion === true)
        requestVersion = undefined;
    var handled = false;
    let statArgs = process.argv.concat();
    statArgs.splice(0, 2);
    var statData = {
        command: args.command,
        parameters: statArgs.join(' '),
        path: process.cwd(),
        source: process.title
    };
    let userName = selector.getUserName();
    if (args.command === "versions") {
        handled = true;
        printVersions();
    }
    if(args.command === "paths"){
        handled = true;
        printTools();
    }
    if(handled){
        stat.egretStat("cmd", userName, statData);
        return;
    }
    var projectVersion = getProjectVersion();
    statData["egretversion"] = projectVersion;
    stat.egretStat("cmd", userName, statData);
    var projectVersion = getProjectVersion();
    var latestVersion = selector.chooseLatestEngine();
    if (!latestVersion) {
        console.log(tr(2));
        process.exit(2);
        return;
    }
    if (args.command === "make") {
        if (!requestVersion) {
            console.log(tr(11));
            return;
        }
    }
    if (args.command == "upgrade") {
        if (!projectVersion) {
            console.log(tr(7));
            return;
        }
        if (!requestVersion) {
            let upgradeableEngines = [];
            if (projectVersion) {
                Object.keys(engines).sort(compareVersion).reverse().forEach(function (v) {
                    let value = compareVersion(engines[v].version, projectVersion);
                    if (value > 0) {
                        upgradeableEngines.push(engines[v].version);
                    } else if (value === 0) {
                        upgradeableEngines.push(engines[v].version + " [" + tr(10) + "]");
                    }
                });
            }
            console.log(tr(6));
            upgradeableEngines.forEach(function (e) {
                console.log(e);
            });
            return;
        }
        if (compareVersion(requestVersion, projectVersion) < 0) {
            console.log(tr(8, projectVersion));
            return;
        }
        if (compareVersion(requestVersion, projectVersion) == 0) {
            console.log(tr(9, projectVersion));
            return;
        }
    }
    if (requestVersion || (projectVersion && !(args.command in commandsToSkip))) {
        requestVersion = requestVersion || projectVersion;
        if (!engines[requestVersion]) {
            console.log(tr(1, requestVersion));
            process.exit(1);
            return;
        }
        if (projectVersion && !(args.command in commandsToSkip) && compareVersion(projectVersion, latestVersion.version) < 0) {
            console.log(tr(3, latestVersion.version, projectVersion));
        }
        executeVersion(requestVersion);
        return;
    }
    if (!handled) {
        executeVersion(latestVersion.version, latestVersion.root);
    }
}
function printVersions() {
    if (!engines) {
        getAllEngineVersions();
    }
    Object.keys(engines).sort(compareVersion).reverse().forEach(function (v) {
        console.log(("Egret Engine " + engines[v].version + "  ") + engines[v].root);
    });
}
function printTools() {
    let tools = selector.getInstalledTools();
    console.log(JSON.stringify(tools, null, "    "));
}
function executeVersion(version, root) {
    root = root || engines[version].root;
    var bin = selector.getBin(root);
    process.env["EGRET_PATH"] = root;
    //Fix 1.5 can not find typescript lib
    if (process['mainModule']) {
        process['mainModule'].filename = bin;
    }
    require(bin);
    return true;
}

function getProjectVersion() {
    var dir;
    if (args.command != "create_app") {
        dir = args.projectDir;
    }
    else {
        dir = args["f"];
    }
    var propsPath = file.joinPath(dir, "egretProperties.json");
    if(!file.exists(propsPath)){
        propsPath = file.joinPath(dir, "package.json");
    }
    if (file.exists(propsPath)) {
        var jsonText = file.read(propsPath);
        var props;
        try {
            props = JSON.parse(jsonText);
        }
        catch (e) {
            console.log(tr(5));
            process.exit(2);
        }
        if (props["compilerVersion"]) {
            return props["compilerVersion"];
        }
        if (props["egret_version"]) {
            return props["egret_version"];
        }
        return props["version"];
    }
    return null;
}

function tr(code) {
    var args = [];
    for (var _i = 1; _i < arguments.length; _i++) {
        args[_i - 1] = arguments[_i];
    }
    var messages = localsMessages[language];
    var message = messages[code];
    message = format(message, args);
    return message;
}
function format(text, args) {
    var length = args.length;
    for (var i = 0; i < length; i++) {
        text = text.replace(new RegExp("\{" + i + "\}", "ig"), args[i]);
    }
    return text;
}
function parseArgs() {
    var i = 0;
    var commands = [];
    var options = {};
    var args = process.argv.concat();
    args.splice(0, 2);
    while (i < args.length) {
        var s = args[i++];
        if (s.charAt(0) === '-') {
            s = s.slice(s.charAt(1) === '-' ? 2 : 1).toLowerCase();
            if (!args[i] || args[i].charAt(0) == '-') {
                options[s] = true;
            }
            else {
                options[s] = args[i++] || "";
            }
        }
        else {
            commands.push(s);
        }
    }
    if (commands.length > 0) {
        options.command = commands[0];
        if (commands.length > 1 && file.isDirectory(commands[1])) {
            options.projectDir = commands[1];
        }
    }
    if (options.projectDir == null) {
        options.projectDir = process.cwd();
    }
    else {
        var absPath = file.joinPath(process.cwd(), options.projectDir);
        if (file.isDirectory(absPath)) {
            options.projectDir = absPath;
        }
    }
    options.projectDir = file.joinPath(options.projectDir, "/");
    return options;
}
function compareVersion(v1, v2) {
    return versionToNumber(v1) - versionToNumber(v2);
    function versionToNumber(v) {
        var numbers = v.split(".").map(function (n) {
            try {
                return parseInt(n) || 0;
            }
            catch (e) {
                return 0;
            }
        });
        var total = 0;
        numbers.forEach(function (n, i) {
            total += n * Math.pow(0.01, i);
        });
        return total;
    }
}
var file;
(function (file) {
    var charset = "utf-8";
    /**
     * 指定路径的文件或文件夹是否存在
     */
    function exists(path) {
        path = escapePath(path);
        return FS.existsSync(path);
    }
    file.exists = exists;
    /**
     * 转换本机路径为Unix风格路径。
     */
    function escapePath(path) {
        if (!path)
            return "";
        return path.split("\").join("/");
    }
    file.escapePath = escapePath;
    /**
     * 读取文本文件,返回打开文本的字符串内容，若失败，返回"".
     * @param path 要打开的文件路径
     */
    function read(path, ignoreCache) {
        if (ignoreCache === void 0) { ignoreCache = false; }
        path = escapePath(path);
        try {
            var text = FS.readFileSync(path, charset);
            text = text.replace(/^uFEFF/, '');
        }
        catch (err0) {
            return "";
        }
        return text;
    }
    file.read = read;
    /**
     * 连接路径,支持传入多于两个的参数。也支持"../"相对路径解析。返回的分隔符为Unix风格。
     */
    function joinPath(dir) {
        var filename = [];
        for (var _i = 1; _i < arguments.length; _i++) {
            filename[_i - 1] = arguments[_i];
        }
        var path = Path.join.apply(null, arguments);
        path = escapePath(path);
        return path;
    }
    file.joinPath = joinPath;
    function isDirectory(path) {
        path = escapePath(path);
        try {
            var stat = FS.statSync(path);
        }
        catch (e) {
            return false;
        }
        return stat.isDirectory();
    }
    file.isDirectory = isDirectory;
    /**
     * 获取指定文件夹下的文件或文件夹列表，不包含子文件夹内的文件。
     * @param path 要搜索的文件夹
     * @param relative 是否返回相对路径，若不传入或传入false，都返回绝对路径。
     */
    function getDirectoryListing(path, relative) {
        if (relative === void 0) { relative = false; }
        path = escapePath(path);
        try {
            var list = FS.readdirSync(path);
        }
        catch (e) {
            return [];
        }
        var length = list.length;
        if (!relative) {
            for (var i = length - 1; i >= 0; i--) {
                if (list[i].charAt(0) == ".") {
                    list.splice(i, 1);
                }
                else {
                    list[i] = joinPath(path, list[i]);
                }
            }
        }
        else {
            for (i = length - 1; i >= 0; i--) {
                if (list[i].charAt(0) == ".") {
                    list.splice(i, 1);
                }
            }
        }
        return list;
    }
    file.getDirectoryListing = getDirectoryListing;
    /**
     * 获取路径的文件名(不含扩展名)或文件夹名
     */
    function getFileName(path) {
        if (!path)
            return "";
        path = escapePath(path);
        var startIndex = path.lastIndexOf("/");
        var endIndex;
        if (startIndex > 0 && startIndex == path.length - 1) {
            path = path.substring(0, path.length - 1);
            startIndex = path.lastIndexOf("/");
            endIndex = path.length;
            return path.substring(startIndex + 1, endIndex);
        }
        endIndex = path.lastIndexOf(".");
        if (endIndex == -1 || isDirectory(path))
            endIndex = path.length;
        return path.substring(startIndex + 1, endIndex);
    }
    file.getFileName = getFileName;
})(file || (file = {}));
function getLanguage() {
    var selector = process['mainModule'].filename;
    var languageXML = file.escapePath(file.joinPath(Path.dirname(selector), '../locales/language.xml'));
    if (file.exists(languageXML)) {
        var xml = file.read(languageXML);
        var lang = /<language>([w_]*)</language>/.exec(xml);
        if (lang) {
            var localParts = lang[1].split('_');
            if (localParts.length >= 1) {
                language = localParts[0];
            }
        }
    }
    if (!language || language != "zh") {
        language = "en";
    }
}
entry();

 这个里面其他都不用关心，最后就是到了executeVersion函数里面。

 就是require(bin);//bin:/Users/UserName/Library/Application Support/Egret/engine/5.3.7/tools/bin/egret

而这个就是egret就是引擎下面的egret文件，

我们进去看，其实就一句话：

require('../Entry.js').executeCommandLine(process.argv.slice(2))

即包含了../Entry.js，然后执行返回对象的executeCommandLine(process.argv.slice(2))。

这就真的进入了引擎的Entry.js文件，执行执行命令行函数了。

所以就是从这里进入了引擎代码里面了，接下来就去看引擎代码就好啦。