ace/tool/tmlanguage.js

var fs = require("fs");
var util = require("util");
var lib = require("./lib");
var parseLanguage = lib.parsePlist;


function logDebug(string, obj) {
    console.log(string, obj);
}


// tmLanguage processor

// for tracking token states
var states = {start: []};
var stateName = "start";

function processRules(rules){
    if (rules.patterns)
        states.start = processPatterns(rules.patterns);
    if (rules.repository)
        processRepository(rules.repository);
    return states;
}
function processRepository(r) {
    for (var key in r) {
        var p = r[key];
        if (p.begin)
            var stateObj = [processPattern(r[key])];
        else if (p.patterns && !p.repository)
            var stateObj = processPatterns(p.patterns);
        else
            var stateObj = [processPattern(r[key])];

        if (stateObj)
            states["#" + key] = stateObj;
    }
}
function processPatterns(pl) {
    return pl.map(processPattern);
}
function processPattern(p) {

    if (p.end == "(?!\\G)" && p.patterns && p.patterns.length == 1) {
        var rule = processPattern(p.patterns[0]);
    }
    else if (p.begin && p.end) {
        var rule = simpleRule(p.begin, p.name, p.beginCaptures || p.captures)

        var next = processPatterns(p.patterns || []);
        var endRule = simpleRule(p.end, p.name, p.endCaptures || p.captures);
        endRule.next = "pop";
        next.push(endRule);

        if (p.name || p.contentName)
            next.push({defaultToken: p.name || p.contentName});

        rule.push = next;
    }
    else if (p.match) {
        var rule = simpleRule(p.match, p.name, p.captures)
    }
    else if (p.include) {
        var rule =  {include: p.include};
    }

    if (p.comment)
        rule.comment = (rule.comment || "") +  p.comment;

    if (p.repository)
        processRepository(p.repository);
    return rule;
}
function simpleRule(regex, name, captures) {
    name = name || "text";
    var rule = {};

    var origRegex = regex
    regex = transformRegExp(regex, rule);
    if (captures) {
        var tokenArray = [];
        Object.keys(captures).forEach(function(x){
            tokenArray[x] = captures[x] && captures[x].name;
        });
        if (tokenArray.length == 1) {
            name = tokenArray[0];
        } else {
            for (var i = 0; i < tokenArray.length; i++)
                if (!tokenArray[i])
                    tokenArray[i] = name;
            name = tokenArray;
            rule.todo = "fix grouping";
        }
    }

    try {new RegExp(regex);} catch(e) {
        rule.TODO = "FIXME: regexp doesn't have js equivalent";
        rule.originalRegex = origRegex
    }
    rule.token = name;
    rule.regex = regex;
    return rule;
}


// regex transformation

function removeXFlag(str) {
    if (str && str.slice(0,4) == "(?x)") {
        str = str.replace(/\\.|\[([^\]\\]|\\.)*?\]|\s+|(?:#[^\n]*)/g, function(s) {
            if (s[0] == "[")
                return s;
            if (s[0] == "\\")
                return /[#\s]/.test(s[1]) ? s[1] : s;
            return "";
        }).substr(4);
    }
    return str;
}

function transformRegExp(str, rule) {
    str = removeXFlag(str);
    //str = str.replace(/\\n\$|\$\\n/g, '$');
    str = str.replace(/\\n(?!\?).?/g, '$'); // replace newlines by $ except if its postfixed by ?
    if (/\(\?[i]\:|\(?\w*i\w*\)/g.test(str)) {
        str = str.replace(/\(\?[ims\-]\:/g, "(?:"); // checkForInvariantRegex
        str = str.replace(/\(\?[imsx\-]\)/g, "");
        rule && (rule.caseInsensitive = true);
    }
    str = str.replace(/(\\[xu]){([a-fA-F\d]+)}/g, '$1$2');
    return str;
}

//
function extractPatterns(tmRules) {
    var patterns = processRules(tmRules);
    return lib.restoreJSONComments(lib.formatJSON(patterns, "    "));

}



// cli stuff
var modeTemplate = fs.readFileSync(__dirname + "/mode.tmpl.js", "utf8");
var modeHighlightTemplate = fs.readFileSync(__dirname + "/mode_highlight_rules.tmpl.js", "utf8");

function convertLanguageFile(name) {
    var path = /^(\/|\w:)/.test(name) ? name : process.cwd() + "/" + name
    var tmLanguage = fs.readFileSync(path, "utf8");
    parseLanguage(tmLanguage, function(language) {
        var languageHighlightFilename = language.name.replace(/[-_]/g, "").toLowerCase();
        var languageNameSanitized = language.name.replace(/-/g, "");

        var languageHighlightFile = __dirname + "/../lib/ace/mode/" + languageHighlightFilename + "_highlight_rules.js";
        var languageModeFile = __dirname + "/../lib/ace/mode/" + languageHighlightFilename + ".js";

        console.log("Converting " + name + " to " + languageHighlightFile);

        if (devMode) {
            console.log(util.inspect(language.patterns, false, 4));
            console.log(util.inspect(language.repository, false, 4));
        }

        var languageMode = lib.fillTemplate(modeTemplate, {
            language: languageNameSanitized,
            languageHighlightFilename: languageHighlightFilename
        });

        var patterns = extractPatterns(language);

        var languageHighlightRules = lib.fillTemplate(modeHighlightTemplate, {
            language: languageNameSanitized,
            languageTokens: patterns.trim(),
            uuid: language.uuid,
            name: name
        });

        if (devMode) {
            console.log(languageMode);
            console.log(languageHighlightRules);
            console.log("Not writing, 'cause we're in dev mode, baby.");
        }
        else {
            fs.writeFileSync(languageHighlightFile, languageHighlightRules);
            fs.writeFileSync(languageModeFile, languageMode);
        }
    });
}

var args = process.argv.splice(2);
var tmLanguageFile  = args[0];
var devMode         = args[1];
if (tmLanguageFile === undefined) {
    console.error("Please pass in a language file via the command line.");
    process.exit(1);
}
convertLanguageFile(tmLanguageFile);