atom-syntax-tools/index.js

// Generated by CoffeeScript 1.7.1
(function() {
  var GrammarCreator, makeGrammar;

  GrammarCreator = (function() {
    function GrammarCreator(grammar, print) {
      this.grammar = grammar;
      this.print = print != null ? print : false;
    }

    GrammarCreator.prototype.process = function() {
      var CSON, G, all_done, grammar, k, macros, n, pats, print, v, _i, _len, _ref, _ref1, _ref2;
      grammar = this.grammar;
      print = this.print;
      G = {};
      _ref = ["comment", "fileTypes", "firstLineMatch", "keyEquivalent", "name", "scopeName"];
      for (_i = 0, _len = _ref.length; _i < _len; _i++) {
        n = _ref[_i];
        if (grammar[n] != null) {
          G[n] = grammar[n];
        }
      }
      this.autoAppendScopeName = grammar.autoAppendScopeName, this.macros = grammar.macros;
      if (typeof this.autoAppendScopeName === "undefined") {
        this.autoAppendScopeName = true;
      }
      if (typeof this.macros === "undefined") {
        this.macros = {};
      }
      this.grammarScopeName = G.scopeName.replace(/.*\./, '');
      this.hasGrammarScopeName = new RegExp("\\." + this.grammarScopeName + "$");
      macros = this.macros;
      for (k in macros) {
        v = macros[k];
        if (v instanceof RegExp) {
          macros[k] = v.source;
        }
      }
      for (k in macros) {
        v = macros[k];
        macros[k] = this.resolveMacros(v);
      }
      while (true) {
        all_done = true;
        for (k in macros) {
          v = macros[k];
          macros[k] = this.resolveMacros(v);
          if (/\{[a-zA-Z_]\w*\}/.test(macros[k])) {
            all_done = false;
            if (v === macros[k]) {
              throw "unresolved macro in " + v;
            }
          }
        }
        if (all_done) {
          break;
        }
      }
      _ref1 = this.makePattern(grammar);
      for (k in _ref1) {
        v = _ref1[k];
        G[k] = v;
      }
      if (grammar.repository != null) {
        G.repository = {};
        _ref2 = grammar.repository;
        for (k in _ref2) {
          v = _ref2[k];
          pats = this.makePattern(v, macros);
          if ((pats.begin != null) || (pats.match != null)) {
            pats = {
              "patterns": [pats]
            };
          } else if (pats instanceof Array) {
            pats = {
              "patterns": pats
            };
          }
          G.repository[k] = pats;
        }
      }
      if (print) {
        if (print === "CSON") {
          CSON = require("CSON");
          process.stdout.write(CSON.stringify(G));
        } else {
          process.stdout.write(JSON.stringify(G, null, "    "));
        }
      }
      return G;
    };

    GrammarCreator.prototype.resolveMacros = function(regex) {
      var macros;
      if (regex instanceof RegExp) {
        regex = regex.source;
      }
      macros = this.macros;
      return regex.replace(/\{\w+\}/g, function(mob) {
        var s;
        s = mob.slice(1, -1);
        if (typeof macros[s] !== "undefined") {
          return macros[s];
        } else {
          return mob;
        }
      });
    };

    GrammarCreator.prototype.makeScopeName = function(name) {
      name = this.resolveMacros(name);
      if (this.autoAppendScopeName) {
        if (!this.hasGrammarScopeName.test(name)) {
          return "" + name + "." + this.grammarScopeName;
        }
      }
      return name;
    };

    GrammarCreator.prototype.makePattern = function(pattern) {
      var P, c, ck, cv, k, p, pat, v;
      pat = pattern;
      P = {};
      if (typeof pattern === "string") {
        P.include = pattern;
        return P;
      }
      if (pattern instanceof Array) {
        return (function() {
          var _i, _len, _results;
          _results = [];
          for (_i = 0, _len = pattern.length; _i < _len; _i++) {
            p = pattern[_i];
            _results.push(this.makePattern(p));
          }
          return _results;
        }).call(this);
      }
      for (k in pat) {
        v = pat[k];
        switch (k) {
          case "N":
          case "contentName":
            P.contentName = this.makeScopeName(v);
            break;
          case "i":
          case "include":
            P.include = v;
            break;
          case "n":
          case "name":
            P.name = this.makeScopeName(v);
            break;
          case "m":
          case "match":
            P.match = this.resolveMacros(v);
            break;
          case "b":
          case "begin":
            P.begin = this.resolveMacros(v);
            break;
          case "e":
          case "end":
            P.end = this.resolveMacros(v);
            break;
          case "c":
          case "captures":
          case "beginCaptures":
            if (P.begin != null) {
              P.beginCaptures = c = {};
            } else {
              P.captures = c = {};
            }
            if (typeof v === "string") {
              c[0] = {
                name: this.makeScopeName(v)
              };
            } else {
              for (ck in v) {
                cv = v[ck];
                if (typeof cv !== "string") {
                  c[ck] = this.makePattern(cv);
                } else {
                  c[ck] = {
                    name: this.makeScopeName(cv)
                  };
                }
              }
            }
            break;
          case "C":
          case "endCaptures":
            P.endCaptures = c = {};
            if (typeof v === "string") {
              c[0] = {
                name: this.makeScopeName(v)
              };
            } else {
              for (ck in v) {
                cv = v[ck];
                if (typeof cv !== "string") {
                  c[ck] = this.makePattern(cv);
                } else {
                  c[ck] = {
                    name: this.makeScopeName(cv)
                  };
                }
              }
            }
            break;
          case "p":
          case "patterns":
            if (!(v instanceof Array)) {
              v = [v];
            }
            P.patterns = (function() {
              var _i, _len, _results;
              _results = [];
              for (_i = 0, _len = v.length; _i < _len; _i++) {
                p = v[_i];
                _results.push(this.makePattern(p));
              }
              return _results;
            }).call(this);
            break;
          case "L":
          case "applyEndPatternLast":
            P.applyEndPatternLast = v;
            break;
          default:
            P[k] = v;
        }
      }
      return P;
    };

    return GrammarCreator;

  })();

  makeGrammar = function(grammar, print) {
    if (print == null) {
      print = false;
    }
    return (new GrammarCreator(grammar, print)).process();
  };

  module.exports = makeGrammar;

}).call(this);