Add ability to generate Atom test specs; bump version to 0.0.14

Author: 1st1

bin/syntaxdev.js

@@ -55,6 +55,36 @@ testCli.addArgument([ '--add-syntax' ], {
 });
 
 
+var atomSpecCli = sub.addParser('atom-spec');
+
+atomSpecCli.addArgument([ '--tests' ], {
+    help: 'Test files, ex: "--tests test/**/*.test"',
+    nargs: '*',
+    action: 'append',
+    required: true
+});
+
+atomSpecCli.addArgument([ '--syntax' ], {
+    help: 'Syntax file in YAML format, ex: "--syntax FooLang.YAML-tmLanguage"',
+    required: true
+});
+
+atomSpecCli.addArgument([ '--add-syntax' ], {
+    help: 'Additional syntax files in YAML format',
+    nargs: '*',
+    action: 'append'
+});
+
+atomSpecCli.addArgument([ '--out' ], {
+    help: '"out" JS file',
+    required: true
+});
+
+atomSpecCli.addArgument([ '--package-name' ], {
+    required: true
+});
+
+
 var buildCsonCli = sub.addParser('build-cson');
 
 buildCsonCli.addArgument([ '--in' ], {
@@ -94,6 +124,17 @@ function main() {
                                                     uniq().sort().value()
             }
         );
+    } else if (options.command == 'atom-spec') {
+        syntaxdev.generateAtomSpec(
+            _.chain(options.tests).flatten().uniq().sort().value(),
+            options.syntax,
+            {
+                out: options.out,
+                add_syntaxes: _.chain(options.add_syntax).flatten().
+                                                    uniq().sort().value(),
+                packageName: options.package_name,
+            }
+        );
     } else if (options.command == 'build-cson') {
         syntaxdev.buildCson(options.in, options.out);
     } else if (options.command == 'build-plist') {

index.js

@@ -140,19 +140,12 @@ function compileGrammar(grammarFile, additionalGrammars) {
 }
 
 
-function testFile(file, grammar, options) {
-    function padRight(str, pad) {
-        if (str.length < pad) {
-            return str + (new Array(pad - str.length)).join(' ');
-        }
-
-        return str;
-    }
+function stripnl(str){
+    return str.replace(/^\n+/, '').replace(/\n+$/, '');
+}
 
-    function stripnl(str){
-        return str.replace(/^\n+/, '').replace(/\n+$/, '');
-    }
 
+function readTestFile(file) {
     function rpartition(str, separator) {
         if (!separator) {
             throw new Error('empty separator')
@@ -171,8 +164,50 @@ function testFile(file, grammar, options) {
         }
     }
 
+    var buf = fs.readFileSync(file, 'utf8'),
+        parts = rpartition(buf, '\n\n\n'),
+        source = parts[0],
+        test = parts[2];
+
+    if (test) {
+        test = stripnl(test);
+    }
+
+    if (source) {
+        source = stripnl(source);
+    }
+
+    if (!test) {
+        test = null;
+    }
+
+    if (!source) {
+        source = null;
+    }
+
+    if (!source && test) {
+        source = test;
+        test = null;
+    }
+
+    return {
+        source: source,
+        test: test
+    }
+}
+
+
+function testFile(file, grammar, options) {
+    function padRight(str, pad) {
+        if (str.length < pad) {
+            return str + (new Array(pad - str.length)).join(' ');
+        }
+
+        return str;
+    }
+
     function tokenize(lines) {
-        var lines = grammar.tokenizeLines(stripnl(lines)),
+        var lines = grammar.tokenizeLines(lines),
             result = [];
 
         result = []
@@ -235,23 +270,9 @@ function testFile(file, grammar, options) {
         return result.join('\n');
     }
 
-    var buf = fs.readFileSync(file, 'utf8'),
-        parts = rpartition(buf, '\n\n\n'),
-        source = parts[0],
-        test = parts[2];
-
-    if (test) {
-        test = stripnl(test);
-    }
-
-    if (!test) {
-        test = null;
-    }
-
-    if (!source && test) {
-        source = test;
-        test = null;
-    }
+    var testFile = readTestFile(file),
+        source = testFile.source,
+        test = testFile.test;
 
     if (!source) {
         return {
@@ -336,6 +357,82 @@ function test(testFiles, grammarFile, options) {
 }
 
 
+function generateAtomSpec(testFiles, grammarFile, options) {
+    var grammar = compileGrammar(grammarFile, options.add_syntaxes),
+        specLines = [];
+
+        console.log(grammar.scopeName);
+
+    for (var fi = 0; fi < testFiles.length; fi++) {
+        var fileName = testFiles[fi],
+            testFile = readTestFile(fileName);
+
+        if (!testFile.test || !testFile.source) {
+            continue;
+        }
+
+        var lines = grammar.tokenizeLines(testFile.source),
+            testLines = [];
+
+        testLines.push(
+            'tokens = grammar.tokenizeLines(' +
+            JSON.stringify(testFile.source) +
+            ')')
+
+        for (var i = 0; i < lines.length; i++) {
+            var line = lines[i];
+
+            for (var j = 0; j < line.length; j++) {
+                var value = line[j].value,
+                    scopes = line[j].scopes;
+
+                testLines.push(
+                    'expect(tokens[' + i + '][' + j + '].value)' +
+                    '.toBe(' + JSON.stringify(value) + ');')
+
+                testLines.push(
+                    'expect(tokens[' + i + '][' + j + '].scopes)' +
+                    '.toEqual(' + JSON.stringify(scopes) + ');')
+            }
+        }
+
+        specLines.push({
+            file: fileName,
+            lines: testLines
+        })
+    }
+
+    var buf = [
+        '// !!! autogenerated; do not edit !!!\n\n\n',
+        'describe("Grammar Tests", function() {',
+        '  var grammar = null;',
+        '  beforeEach(function() {',
+        '    waitsForPromise(function() {',
+        '      return atom.packages.activatePackage(' +
+                    JSON.stringify(options.packageName) + ')',
+        '    });',
+        '    runs(function() {',
+        '      grammar = atom.grammars.grammarForScopeName(' +
+                    JSON.stringify(grammar.scopeName) + ')',
+        '    });',
+        '  });',
+        ''
+    ];
+
+    for (i = 0; i < specLines.length; i++) {
+        buf.push('  it(' + JSON.stringify(specLines[i].file) + ', ');
+        buf.push('  function() {')
+        buf.push('    ' + specLines[i].lines.join('\n    '));
+        buf.push('  });');
+    }
+
+    buf.push('});\n');
+    buf = buf.join('\n');
+
+    fs.writeFileSync(options.out, buf + '\n');
+}
+
+
 function buildCson(inName, outName) {
     var yamlSchema = readGrammarFile(inName, false),
         csonSource = cson.createCSONString(yamlSchema, {indent: 2});
@@ -401,6 +498,7 @@ function listScopes(grammarFile) {
 
 module.exports = {
     test: test,
+    generateAtomSpec: generateAtomSpec,
     buildCson: buildCson,
     buildPList: buildPList,
     listScopes: listScopes

package.json

@@ -1,6 +1,6 @@
 {
   "name": "syntaxdev",
-  "version": "0.0.13",
+  "version": "0.0.14",
   "description": "Unit testing framework for TextMate/Sublime/Atom syntaxes.",
   "main": "index.js",
   "author": "Yury Selivanov <yury@magic.io>",