refactor application.yaml to become an os definition #40

src/application/Parser/ApplicationParser.ts

@@ -1,14 +1,18 @@
 import { Category } from '@/domain/Category';
 import { Application } from '@/domain/Application';
 import { IApplication } from '@/domain/IApplication';
-import { IProjectInformation } from '@/domain/IProjectInformation';
-import { ApplicationYaml } from 'js-yaml-loader!./../application.yaml';
+import { YamlApplication } from 'js-yaml-loader!./../application.yaml';
 import { parseCategory } from './CategoryParser';
-import { ProjectInformation } from '@/domain/ProjectInformation';
+import { parseProjectInformation } from './ProjectInformationParser';
 import { ScriptCompiler } from './Compiler/ScriptCompiler';
+import { OperatingSystem } from '@/domain/OperatingSystem';
+import { parseScriptingDefinition } from './ScriptingDefinitionParser';
+import { createEnumParser } from '../Common/Enum';
 
-
-export function parseApplication(content: ApplicationYaml, env: NodeJS.ProcessEnv = process.env): IApplication {
+export function parseApplication(
+    content: YamlApplication,
+    env: NodeJS.ProcessEnv = process.env,
+    osParser = createEnumParser(OperatingSystem)): IApplication {
     validate(content);
     const compiler = new ScriptCompiler(content.functions);
     const categories = new Array<Category>();
@@ -16,23 +20,18 @@ export function parseApplication(content: ApplicationYaml, env: NodeJS.ProcessEn
         const category = parseCategory(action, compiler);
         categories.push(category);
     }
-    const info = readAppInformation(env);
+    const os = osParser.parseEnum(content.os, 'os');
+    const info = parseProjectInformation(env);
+    const scripting = parseScriptingDefinition(content.scripting, info);
     const app = new Application(
+        os,
         info,
-        categories);
+        categories,
+        scripting);
     return app;
 }
 
-function readAppInformation(environment: NodeJS.ProcessEnv): IProjectInformation {
-    return new ProjectInformation(
-        environment.VUE_APP_NAME,
-        environment.VUE_APP_VERSION,
-        environment.VUE_APP_REPOSITORY_URL,
-        environment.VUE_APP_HOMEPAGE_URL,
-    );
-}
-
-function validate(content: ApplicationYaml): void {
+function validate(content: YamlApplication): void {
     if (!content) {
         throw new Error('application is null or undefined');
     }

src/application/Parser/Compiler/ILCode.ts

@@ -0,0 +1,73 @@
+export interface IILCode {
+    compile(): string;
+    getUniqueParameterNames(): string[];
+    substituteParameter(parameterName: string, parameterValue: string): IILCode;
+}
+
+export function generateIlCode(rawText: string): IILCode {
+    const ilCode = generateIl(rawText);
+    return new ILCode(ilCode);
+}
+
+class ILCode implements IILCode {
+    private readonly ilCode: string;
+
+    constructor(ilCode: string) {
+        this.ilCode = ilCode;
+    }
+
+    public substituteParameter(parameterName: string, parameterValue: string): IILCode {
+        const newCode = substituteParameter(this.ilCode, parameterName, parameterValue);
+        return new ILCode(newCode);
+    }
+
+    public getUniqueParameterNames(): string[] {
+        return getUniqueParameterNames(this.ilCode);
+    }
+
+    public compile(): string {
+        ensureNoExpressionLeft(this.ilCode);
+        return this.ilCode;
+    }
+}
+
+// Trim each expression and put them inside "{{exp|}}" e.g. "{{ $hello }}" becomes "{{exp|$hello}}"
+function generateIl(rawText: string): string {
+    return rawText.replace(/\{\{([\s]*[^;\s\{]+[\s]*)\}\}/g, (_, match) => {
+        return `\{\{exp|${match.trim()}\}\}`;
+    });
+}
+
+// finds all "{{exp|..}} left"
+function ensureNoExpressionLeft(ilCode: string) {
+    const allSubstitutions = ilCode.matchAll(/\{\{exp\|(.*?)\}\}/g);
+    const allMatches = Array.from(allSubstitutions, (match) => match[1]);
+    const uniqueExpressions = getDistinctValues(allMatches);
+    if (uniqueExpressions.length > 0) {
+        throw new Error(`unknown expression: ${printList(uniqueExpressions)}`);
+    }
+}
+
+// Parses all distinct usages of {{exp|$parameterName}}
+function getUniqueParameterNames(ilCode: string) {
+    const allSubstitutions = ilCode.matchAll(/\{\{exp\|\$([^;\s\{]+[\s]*)\}\}/g);
+    const allParameters = Array.from(allSubstitutions, (match) => match[1]);
+    const uniqueParameterNames = getDistinctValues(allParameters);
+    return uniqueParameterNames;
+}
+
+// substitutes {{exp|$parameterName}} to value of the parameter
+function substituteParameter(ilCode: string, parameterName: string, parameterValue: string) {
+    const pattern = `{{exp|$${parameterName}}}`;
+    return ilCode.split(pattern).join(parameterValue); // as .replaceAll() is not yet supported by TS
+}
+
+function getDistinctValues(values: readonly string[]): string[] {
+    return values.filter((value, index, self) => {
+        return self.indexOf(value) === index;
+      });
+}
+
+function printList(list: readonly string[]): string {
+    return `"${list.join('","')}"`;
+}

src/application/Parser/Compiler/ScriptCompiler.ts

@@ -1,3 +1,4 @@
+import { generateIlCode, IILCode } from './ILCode';
 import { IScriptCode } from '@/domain/IScriptCode';
 import { ScriptCode } from '@/domain/ScriptCode';
 import { YamlScript, YamlFunction, FunctionCall, ScriptFunctionCall, FunctionCallParameters } from 'js-yaml-loader!./application.yaml';
@@ -125,20 +126,22 @@ function compileCode(func: YamlFunction, parameters: FunctionCallParameters): IC
 }
 
 function compileExpressions(code: string, parameters: FunctionCallParameters): string {
-    let intermediateCode = compileToIL(code);
+    let intermediateCode = generateIlCode(code);
     intermediateCode = substituteParameters(intermediateCode, parameters);
-    ensureNoExpressionLeft(intermediateCode);
-    return intermediateCode;
+    return intermediateCode.compile();
 }
 
-function substituteParameters(intermediateCode: string, parameters: FunctionCallParameters): string {
-    const parameterNames = getUniqueParameterNamesFromIL(intermediateCode);
+function substituteParameters(intermediateCode: IILCode, parameters: FunctionCallParameters): IILCode {
+    const parameterNames = intermediateCode.getUniqueParameterNames();
     if (parameterNames.length && !parameters) {
         throw new Error(`no parameters defined, expected: ${printList(parameterNames)}`);
     }
     for (const parameterName of parameterNames) {
         const parameterValue = parameters[parameterName];
-        intermediateCode = substituteParameter(intermediateCode, parameterName, parameterValue);
+        if (!parameterValue) {
+            throw Error(`parameter value is not provided for "${parameterName}" in function call`);
+        }
+        intermediateCode = intermediateCode.substituteParameter(parameterName, parameterValue);
     }
     return intermediateCode;
 }
@@ -158,43 +161,3 @@ function getCallSequence(call: ScriptFunctionCall): FunctionCall[] {
     }
     return [ call as FunctionCall ];
 }
-
-function getDistinctValues(values: readonly string[]): string[] {
-    return values.filter((value, index, self) => {
-        return self.indexOf(value) === index;
-      });
-}
-
-// Trim each expression and put them inside "{{exp|}}" e.g. "{{ $hello }}" becomes "{{exp|$hello}}"
-function compileToIL(code: string) {
-    return code.replace(/\{\{([\s]*[^;\s\{]+[\s]*)\}\}/g, (_, match) => {
-        return `\{\{exp|${match.trim()}\}\}`;
-    });
-}
-
-// Parses all distinct usages of {{exp|$parameterName}}
-function getUniqueParameterNamesFromIL(ilCode: string) {
-    const allSubstitutions = ilCode.matchAll(/\{\{exp\|\$([^;\s\{]+[\s]*)\}\}/g);
-    const allParameters = Array.from(allSubstitutions, (match) => match[1]);
-    const uniqueParameterNames = getDistinctValues(allParameters);
-    return uniqueParameterNames;
-}
-
-// substitutes {{exp|$parameterName}} to value of the parameter
-function substituteParameter(ilCode: string, parameterName: string, parameterValue: string) {
-    if (!parameterValue) {
-        throw Error(`parameter value is not provided for "${parameterName}" in function call`);
-    }
-    const pattern = `{{exp|$${parameterName}}}`;
-    return ilCode.split(pattern).join(parameterValue); // as .replaceAll() is not yet supported by TS
-}
-
-// finds all "{{exp|..}} left"
-function ensureNoExpressionLeft(ilCode: string) {
-    const allSubstitutions = ilCode.matchAll(/\{\{exp\|(.*?)\}\}/g);
-    const allMatches = Array.from(allSubstitutions, (match) => match[1]);
-    const uniqueExpressions = getDistinctValues(allMatches);
-    if (uniqueExpressions.length > 0) {
-        throw new Error(`unknown expression: ${printList(uniqueExpressions)}`);
-    }
-}

src/application/Parser/ProjectInformationParser.ts

@@ -0,0 +1,12 @@
+import { IProjectInformation } from '@/domain/IProjectInformation';
+import { ProjectInformation } from '@/domain/ProjectInformation';
+
+export function parseProjectInformation(
+    environment: NodeJS.ProcessEnv): IProjectInformation {
+    return new ProjectInformation(
+        environment.VUE_APP_NAME,
+        environment.VUE_APP_VERSION,
+        environment.VUE_APP_REPOSITORY_URL,
+        environment.VUE_APP_HOMEPAGE_URL,
+    );
+}

src/application/Parser/ScriptParser.ts

@@ -1,37 +1,32 @@
 import { Script } from '@/domain/Script';
 import { YamlScript } from 'js-yaml-loader!./application.yaml';
 import { parseDocUrls } from './DocumentationParser';
-import { RecommendationLevelNames, RecommendationLevel } from '@/domain/RecommendationLevel';
+import { RecommendationLevel } from '@/domain/RecommendationLevel';
 import { IScriptCompiler } from './Compiler/IScriptCompiler';
 import { IScriptCode } from '@/domain/IScriptCode';
 import { ScriptCode } from '@/domain/ScriptCode';
+import { createEnumParser, IEnumParser } from '../Common/Enum';
 
-export function parseScript(yamlScript: YamlScript, compiler: IScriptCompiler): Script {
+export function parseScript(
+    yamlScript: YamlScript, compiler: IScriptCompiler,
+    levelParser = createEnumParser(RecommendationLevel)): Script {
     validateScript(yamlScript);
     if (!compiler) {
         throw new Error('undefined compiler');
     }
     const script = new Script(
-        /* name */              yamlScript.name,
-        /* code */              parseCode(yamlScript, compiler),
-        /* docs */              parseDocUrls(yamlScript),
-        /* level */             getLevel(yamlScript.recommend));
+        /* name */  yamlScript.name,
+        /* code */  parseCode(yamlScript, compiler),
+        /* docs */  parseDocUrls(yamlScript),
+        /* level */ parseLevel(yamlScript.recommend, levelParser));
     return script;
 }
 
-function getLevel(level: string): RecommendationLevel | undefined {
+function parseLevel(level: string, parser: IEnumParser<RecommendationLevel>): RecommendationLevel | undefined {
     if (!level) {
         return undefined;
     }
-    if (typeof level !== 'string') {
-        throw new Error(`level must be a string but it was ${typeof level}`);
-    }
-    const typedLevel = RecommendationLevelNames
-        .find((l) => l.toLowerCase() === level.toLowerCase());
-    if (!typedLevel) {
-        throw new Error(`unknown level: \"${level}\"`);
-    }
-    return RecommendationLevel[typedLevel as keyof typeof RecommendationLevel];
+    return parser.parseEnum(level, 'level');
 }
 
 function parseCode(yamlScript: YamlScript, compiler: IScriptCompiler): IScriptCode {

src/application/Parser/ScriptingDefinitionParser.ts

@@ -0,0 +1,36 @@
+import { IScriptingDefinition } from '@/domain/IScriptingDefinition';
+import { YamlScriptingDefinition } from 'js-yaml-loader!./application.yaml';
+import { ScriptingDefinition } from '@/domain/ScriptingDefinition';
+import { ScriptingLanguage } from '@/domain/ScriptingLanguage';
+import { IProjectInformation } from '@/domain/IProjectInformation';
+import { createEnumParser } from '../Common/Enum';
+import { generateIlCode } from './Compiler/ILCode';
+
+export function parseScriptingDefinition(
+    definition: YamlScriptingDefinition,
+    info: IProjectInformation,
+    date = new Date(),
+    languageParser = createEnumParser(ScriptingLanguage)): IScriptingDefinition {
+    if (!info) {
+        throw new Error('undefined info');
+    }
+    if (!definition) {
+        throw new Error('undefined definition');
+    }
+    const language = languageParser.parseEnum(definition.language, 'language');
+    const startCode = applySubstitutions(definition.startCode, info, date);
+    const endCode = applySubstitutions(definition.endCode, info, date);
+    return new ScriptingDefinition(
+        language,
+        startCode,
+        endCode,
+    );
+}
+
+function applySubstitutions(code: string, info: IProjectInformation, date: Date): string {
+    let ilCode = generateIlCode(code);
+    ilCode = ilCode.substituteParameter('homepage', info.homepage);
+    ilCode = ilCode.substituteParameter('version', info.version);
+    ilCode = ilCode.substituteParameter('date', date.toUTCString());
+    return ilCode.compile();
+}