Merge pull request #271 from MarcelDiessner/feature/syntaxChecking

Patch feature/syntaxChecking

Author: SchettlerKoehler

engine/engine.ts

@@ -28,35 +28,36 @@ export class Engine {
                 console.log("Environment incomplete: " + this.environmentName + " (ignored)");
            }
         }
-
-        mainloop: for (let stepIndex = 0; stepIndex < this.playbook.steps.length; stepIndex++) {
-            for (let lineIndex = 0; lineIndex < this.playbook.steps[stepIndex].lines.length; lineIndex++) {
-                let runCommand = this.initRunCommand(stepIndex, lineIndex);
-                let foundRunnerToExecuteCommand = false;
-                for (let runnerIndex in this.environment.runners) {
-                    let runner = await this.getRunner(this.environment.runners[runnerIndex]);
-                    if (runner.supports(this.playbook.steps[stepIndex].lines[lineIndex].name, this.playbook.steps[stepIndex].lines[lineIndex].parameters)) {
-                        var result = new RunResult();
-                        if(runner.commandIsSkippable(runCommand.command.name)) {
-                            console.log("Command " + runCommand.command.name + " will be skipped.");
-                            continue;
-                        }
-                        try {
-                            result = runner.run(runCommand);
+        if(!this.syntaxErrorLogger.activated) {
+            mainloop: for (let stepIndex = 0; stepIndex < this.playbook.steps.length; stepIndex++) {
+                for (let lineIndex = 0; lineIndex < this.playbook.steps[stepIndex].lines.length; lineIndex++) {
+                    let runCommand = this.initRunCommand(stepIndex, lineIndex);
+                    let foundRunnerToExecuteCommand = false;
+                    for (let runnerIndex in this.environment.runners) {
+                        let runner = await this.getRunner(this.environment.runners[runnerIndex]);
+                        if (runner.supports(this.playbook.steps[stepIndex].lines[lineIndex].name, this.playbook.steps[stepIndex].lines[lineIndex].parameters)) {
+                            var result = new RunResult();
+                            if(runner.commandIsSkippable(runCommand.command.name)) {
+                                console.log("Command " + runCommand.command.name + " will be skipped.");
+                                continue;
+                            }
+                            try {
+                                result = runner.run(runCommand);
+                            }
+                            catch (e) {
+                                result.exceptions.push(e);
+                            }
+                            
+                            await runner.assert(runCommand, result);
+                            
+                            foundRunnerToExecuteCommand = true;
+                            break;
                         }
-                        catch (e) {
-                            result.exceptions.push(e);
-                        }
-                        
-                        await runner.assert(runCommand, result);
-                        
-                        foundRunnerToExecuteCommand = true;
-                        break;
                     }
+                    if(!foundRunnerToExecuteCommand && !this.environment.skipMissingFunctions) {
+                        break mainloop;
+                    }   
                 }
-                if(!foundRunnerToExecuteCommand && !this.environment.skipMissingFunctions) {
-                    break mainloop;
-                }   
             }
         }
 
@@ -86,7 +87,8 @@ export class Engine {
             }
         }
         if(missingFunctions.length > 0) {
-            this.syntaxErrorLogger.handle("Environment incomplete: " + this.environmentName + " | Missing functions: \n - " + missingFunctions.join("\n - "));
+            console.log(missingFunctions);
+            this.syntaxErrorLogger.handleMissingFunction(missingFunctions);
             return false;
         } else {
             return true;

engine/run.ts

@@ -45,6 +45,7 @@ class Run {
                     }
                 }
             }
+            this.syntaxErrorLogger.deactivate();
         } catch (error) {
             console.error(error);
             this.errors.push(error);
@@ -72,7 +73,7 @@ class Run {
                 }
             } catch(e) {
                 console.error("Error while parsing playbook: " + playbookDirs[index], e);
-                this.syntaxErrorLogger.handle("Error while parsing playbook: " + playbookDirs[index] + "\n"+ "- " + e);
+                this.syntaxErrorLogger.handleParseError(playbookDirs[index], e);
                 this.errors.push(e);
             }
         }

engine/syntax_error_logger.ts

@@ -4,7 +4,7 @@ import path = require('path');
 export class SyntaxErrorLogger {
     public activated = false;
     private outputDir = __dirname + "/../errors/";
-    private header = "## Syntax Errors found";
+    private errors = new Array;
 
     activate() {
         this.activated = true;
@@ -13,12 +13,33 @@ export class SyntaxErrorLogger {
         }
     }
 
-    handle(message: string) {
+    deactivate() {
+        if(this.activated && this.errors.length > 0){
+            fs.writeFileSync(path.join(this.outputDir, "syntaxErrors.md"), 
+                "## Function(s) not found: \n - " 
+                + this.errors.join("\n - ")  
+                + "\n \n You can find all supported functions and how to use them [here](https://github.com/devonfw-tutorials/tutorials/wiki/Functions).\n" 
+                , {flag: "a"});
+            this.activated = false;
+        }
+    }
+
+    handleMissingFunction(missingFunctions: any[]) {
         if(this.activated){
-            if(!fs.existsSync(path.join(this.outputDir, "syntaxErrors.md"))) {
-                fs.writeFileSync(path.join(this.outputDir, "syntaxErrors.md"), this.header + "\n", {flag: "a"});
-            }
-            fs.writeFileSync(path.join(this.outputDir, "syntaxErrors.md"), message + "\n", {flag: "a"});
+            this.errors = missingFunctions;
+        }
+    }
+
+    handleParseError(playbook, error) {
+        if(this.activated) { 
+            fs.writeFileSync(path.join(this.outputDir, "syntaxErrors.md"), 
+                "## Error while parsing playbook: " 
+                + playbook + 
+                "\n" + "- " 
+                + error + "\n"
+                + "\n You can find informations on the syntax [here](https://github.com/devonfw-tutorials/tutorials/wiki/Tutorials)" + "\n",
+                 {flag: "a"});
+            this.activated = false;
         }
     }
 }