Macros can execute choices. (#21)

chhoumann · web-flow · commit 06e17f0bb95c · 2021-06-21T16:12:05.000+02:00
diff --git a/manifest.json b/manifest.json
@@ -1,7 +1,7 @@
 {
 	"id": "quickadd",
 	"name": "QuickAdd",
-	"version": "0.2.0",
+	"version": "0.2.1",
 	"minAppVersion": "0.12.00",
 	"description": "Quickly add new pages or content to your vault.",
 	"author": "Christian B. B. Houmann",
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "quickadd",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Quickly add new pages or content to your vault.",
   "main": "main.js",
   "scripts": {
diff --git a/src/IChoiceExecutor.ts b/src/IChoiceExecutor.ts
@@ -0,0 +1,5 @@
+import type IChoice from "./types/choices/IChoice";
+
+export interface IChoiceExecutor {
+    execute(choice: IChoice): Promise<void>;
+}
diff --git a/src/MacrosManager.ts b/src/MacrosManager.ts
@@ -3,14 +3,17 @@ import {App, ButtonComponent, Modal, Setting, TextComponent, ToggleComponent} fr
 import {MacroBuilder} from "./gui/MacroBuilder";
 import {QuickAddMacro} from "./types/macros/QuickAddMacro";
 import {log} from "./logger/logManager";
+import type IChoice from "./types/choices/IChoice";
+import {ChoiceType} from "./types/choices/choiceType";
+import type IMultiChoice from "./types/choices/IMultiChoice";
 
 export class MacrosManager extends Modal {
     public waitForClose: Promise<IMacro[]>;
     private resolvePromise: (macros: IMacro[]) => void;
     private rejectPromise: (reason?: any) => void;
     private updateMacroContainer: () => void;
 
-    constructor(public app: App, private macros: IMacro[]) {
+    constructor(public app: App, private macros: IMacro[], private choices: IChoice[]) {
         super(app)
 
         this.waitForClose = new Promise<IMacro[]>(
@@ -82,7 +85,20 @@ export class MacrosManager extends Modal {
             configureButton.buttonEl.style.marginRight = "0";
 
             configureButton.setButtonText("Configure").onClick(async evt => {
-                const newMacro = await new MacroBuilder(this.app, macro).waitForClose;
+                const getReachableChoices = (choices: IChoice[]) => {
+                    let reachableChoices: IChoice[] = [];
+                    choices.forEach(choice => {
+                        if (choice.type === ChoiceType.Multi)
+                            reachableChoices.push(...getReachableChoices((<IMultiChoice>choice).choices));
+
+                        if (choice.type !== ChoiceType.Multi)
+                            reachableChoices.push(choice);
+                    })
+                    return reachableChoices;
+                }
+
+                const reachableChoices = getReachableChoices(this.choices);
+                const newMacro = await new MacroBuilder(this.app, macro, reachableChoices).waitForClose;
 
                 if (newMacro) {
                     this.updateMacro(newMacro);
diff --git a/src/choiceExecutor.ts b/src/choiceExecutor.ts
@@ -9,22 +9,25 @@ import {log} from "./logger/logManager";
 import {TemplateChoiceEngine} from "./engine/TemplateChoiceEngine";
 import {CaptureChoiceEngine} from "./engine/CaptureChoiceEngine";
 import {MacroChoiceEngine} from "./engine/MacroChoiceEngine";
+import type {IChoiceExecutor} from "./IChoiceExecutor";
 
-export class ChoiceExecutor {
-    constructor(private app: App, private plugin: QuickAdd, private choice: IChoice) { }
+export class ChoiceExecutor implements IChoiceExecutor {
+    private variables: Map<string, string> = new Map<string, string>();
 
-    public async execute(): Promise<void> {
-        switch (this.choice.type) {
+    constructor(private app: App, private plugin: QuickAdd) { }
+
+    async execute(choice: IChoice): Promise<void> {
+        switch (choice.type) {
             case ChoiceType.Template:
-                const templateChoice: ITemplateChoice = this.choice as ITemplateChoice;
+                const templateChoice: ITemplateChoice = choice as ITemplateChoice;
                 await this.onChooseTemplateType(templateChoice);
                 break;
             case ChoiceType.Capture:
-                const captureChoice: ICaptureChoice = this.choice as ICaptureChoice;
+                const captureChoice: ICaptureChoice = choice as ICaptureChoice;
                 await this.onChooseCaptureType(captureChoice);
                 break;
             case ChoiceType.Macro:
-                const macroChoice: IMacroChoice = this.choice as IMacroChoice;
+                const macroChoice: IMacroChoice = choice as IMacroChoice;
                 await this.onChooseMacroType(macroChoice);
                 break;
             default:
@@ -38,7 +41,7 @@ export class ChoiceExecutor {
             return;
         }
 
-        await new TemplateChoiceEngine(this.app, this.plugin, templateChoice).run();
+        await new TemplateChoiceEngine(this.app, this.plugin, templateChoice, this).run();
     }
 
     private async onChooseCaptureType(captureChoice: ICaptureChoice) {
@@ -47,10 +50,15 @@ export class ChoiceExecutor {
             return;
         }
 
-        await new CaptureChoiceEngine(this.app, this.plugin, captureChoice).run();
+        await new CaptureChoiceEngine(this.app, this.plugin, captureChoice, this).run();
     }
 
     private async onChooseMacroType(macroChoice: IMacroChoice) {
-        await new MacroChoiceEngine(this.app, macroChoice, this.plugin.settings.macros).run();
+        const macroEngine = await new MacroChoiceEngine(this.app, this.plugin, macroChoice, this.plugin.settings.macros, this, this.variables);
+        await macroEngine.run();
+
+        Object.keys(macroEngine.params.variables).forEach(key => {
+            this.variables.set(key, macroEngine.params.variables[key]);
+        });
     }
 }
diff --git a/src/engine/CaptureChoiceEngine.ts b/src/engine/CaptureChoiceEngine.ts
@@ -7,17 +7,18 @@ import {MARKDOWN_FILE_EXTENSION_REGEX, VALUE_SYNTAX} from "../constants";
 import type QuickAdd from "../main";
 import {QuickAddChoiceEngine} from "./QuickAddChoiceEngine";
 import {SingleTemplateEngine} from "./SingleTemplateEngine";
+import type {IChoiceExecutor} from "../IChoiceExecutor";
 
 export class CaptureChoiceEngine extends QuickAddChoiceEngine {
     choice: ICaptureChoice;
     private formatter: CaptureChoiceFormatter;
     private readonly plugin: QuickAdd;
 
-    constructor(app: App, plugin: QuickAdd, choice: ICaptureChoice) {
+    constructor(app: App, plugin: QuickAdd, choice: ICaptureChoice, private choiceExecutor: IChoiceExecutor) {
         super(app);
         this.choice = choice;
         this.plugin = plugin;
-        this.formatter = new CaptureChoiceFormatter(app, plugin);
+        this.formatter = new CaptureChoiceFormatter(app, plugin, choiceExecutor);
     }
 
     async run(): Promise<void> {
@@ -46,7 +47,7 @@ export class CaptureChoiceEngine extends QuickAddChoiceEngine {
                 await this.app.vault.modify(file, newFileContent);
             } else if (this.choice?.createFileIfItDoesntExist?.enabled) {
                 const singleTemplateEngine: SingleTemplateEngine =
-                    new SingleTemplateEngine(this.app, this.plugin, this.choice.createFileIfItDoesntExist.template);
+                    new SingleTemplateEngine(this.app, this.plugin, this.choice.createFileIfItDoesntExist.template, this.choiceExecutor);
 
                 const fileContent: string = await singleTemplateEngine.run();
                 const createdFile: TFile = await this.createFileWithInput(filePath, fileContent);
diff --git a/src/engine/MacroChoiceEngine.ts b/src/engine/MacroChoiceEngine.ts
@@ -10,15 +10,31 @@ import type {ICommand} from "../types/macros/ICommand";
 import {QuickAddChoiceEngine} from "./QuickAddChoiceEngine";
 import type {IMacro} from "../types/macros/IMacro";
 import GenericSuggester from "../gui/GenericSuggester/genericSuggester";
+import type {IChoiceCommand} from "../types/macros/IChoiceCommand";
+import type IChoice from "../types/choices/IChoice";
+import type QuickAdd from "../main";
+import type {IChoiceExecutor} from "../IChoiceExecutor";
+import {ChoiceType} from "../types/choices/choiceType";
+import type IMultiChoice from "../types/choices/IMultiChoice";
 
 export class MacroChoiceEngine extends QuickAddChoiceEngine {
     public choice: IMacroChoice;
     protected output: string;
-    protected readonly params = {app: this.app, quickAddApi: QuickAddApi.GetApi(this.app)};
+    protected macros: IMacro[];
+    protected choiceExecutor: IChoiceExecutor;
+    public params = {app: this.app, quickAddApi: QuickAddApi.GetApi(this.app), variables: {}};
+    protected readonly plugin: QuickAdd;
 
-    constructor(app: App, choice: IMacroChoice, protected macros: IMacro[]) {
+    constructor(app: App, plugin: QuickAdd, choice: IMacroChoice, macros: IMacro[], choiceExecutor: IChoiceExecutor, variables: Map<string, string>) {
         super(app);
         this.choice = choice;
+        this.plugin = plugin;
+        this.macros = macros;
+        this.choiceExecutor = choiceExecutor;
+
+        variables?.forEach(((value, key) => {
+            this.params.variables[key] = value;
+        }));
     }
 
     async run(): Promise<void> {
@@ -34,6 +50,8 @@ export class MacroChoiceEngine extends QuickAddChoiceEngine {
                 await this.executeObsidianCommand(command as IObsidianCommand);
             if (command?.type === CommandType.UserScript)
                 await this.executeUserScript(command as IUserScript);
+            if (command?.type === CommandType.Choice)
+                await this.executeChoice(command as IChoiceCommand);
         }
     }
 
@@ -108,5 +126,29 @@ export class MacroChoiceEngine extends QuickAddChoiceEngine {
         // @ts-ignore
         this.app.commands.executeCommandById(command.commandId);
     }
-}
 
+    protected async executeChoice(command: IChoiceCommand) {
+        const choices: IChoice[] = this.plugin.settings.choices;
+
+        const findChoice = (choiceArr: IChoice[]) => {
+            let tempChoice: IChoice;
+            for (const choice of choiceArr) {
+                tempChoice = choice;
+
+                if (choice.type === ChoiceType.Multi)
+                    tempChoice = findChoice((<IMultiChoice> choice).choices);
+
+                if (tempChoice.id === command.choiceId)
+                    return tempChoice;
+            }
+        }
+
+        const targetChoice = findChoice(choices);
+        if (!targetChoice) {
+            log.logError("choice could not be found.");
+            return;
+        }
+
+        await this.choiceExecutor.execute(targetChoice);
+    }
+}
diff --git a/src/engine/SingleMacroEngine.ts b/src/engine/SingleMacroEngine.ts
@@ -1,18 +1,14 @@
 import type {App} from "obsidian";
 import type {IMacro} from "../types/macros/IMacro";
 import {MacroChoiceEngine} from "./MacroChoiceEngine";
-import {QuickAddApi} from "../quickAddApi";
+import type QuickAdd from "../main";
+import type {IChoiceExecutor} from "../IChoiceExecutor";
 
 export class SingleMacroEngine extends MacroChoiceEngine {
-    public readonly params = {app: this.app, quickAddApi: QuickAddApi.GetApi(this.app), variables: {}};
     private memberAccess: string[];
 
-    constructor(app: App, macros: IMacro[], private variables: Map<string, string>) {
-        super(app, null, macros);
-
-        variables.forEach(((value, key) => {
-            this.params.variables[key] = value;
-        }));
+    constructor(app: App, plugin: QuickAdd, macros: IMacro[], choiceExecutor: IChoiceExecutor, variables: Map<string, string>) {
+        super(app, plugin, null, macros, choiceExecutor, variables);
     }
 
     public async runAndGetOutput(macroName: string): Promise<string> {
diff --git a/src/engine/SingleTemplateEngine.ts b/src/engine/SingleTemplateEngine.ts
@@ -1,10 +1,11 @@
 import {TemplateEngine} from "./TemplateEngine";
 import type {App} from "obsidian";
 import type QuickAdd from "../main";
+import type {IChoiceExecutor} from "../IChoiceExecutor";
 
 export class SingleTemplateEngine extends TemplateEngine {
-    constructor(app: App, plugin: QuickAdd, private templatePath: string) {
-        super(app, plugin);
+    constructor(app: App, plugin: QuickAdd, private templatePath: string, choiceExecutor: IChoiceExecutor) {
+        super(app, plugin, choiceExecutor);
     }
     public async run(): Promise<string> {
         let templateContent: string = await this.getTemplateContent(this.templatePath);
diff --git a/src/engine/StartupMacroEngine.ts b/src/engine/StartupMacroEngine.ts
@@ -1,10 +1,12 @@
 import type {App} from "obsidian";
 import type {IMacro} from "../types/macros/IMacro";
 import {MacroChoiceEngine} from "./MacroChoiceEngine";
+import type QuickAdd from "../main";
+import type {IChoiceExecutor} from "../IChoiceExecutor";
 
 export class StartupMacroEngine extends MacroChoiceEngine {
-    constructor(app: App, macros: IMacro[]) {
-        super(app, null, macros);
+    constructor(app: App, plugin: QuickAdd, macros: IMacro[], choiceExecutor: IChoiceExecutor) {
+        super(app, plugin, null, macros, choiceExecutor, null);
     }
 
     async run(): Promise<void> {
diff --git a/src/engine/TemplateChoiceEngine.ts b/src/engine/TemplateChoiceEngine.ts
@@ -5,12 +5,13 @@ import {MARKDOWN_FILE_EXTENSION_REGEX} from "../constants";
 import {log} from "../logger/logManager";
 import type QuickAdd from "../main";
 import {TemplateEngine} from "./TemplateEngine";
+import type {IChoiceExecutor} from "../IChoiceExecutor";
 
 export class TemplateChoiceEngine extends TemplateEngine {
     public choice: ITemplateChoice;
 
-    constructor(app: App, plugin: QuickAdd, choice: ITemplateChoice) {
-        super(app, plugin);
+    constructor(app: App, plugin: QuickAdd, choice: ITemplateChoice, choiceExecutor: IChoiceExecutor) {
+        super(app, plugin, choiceExecutor);
         this.choice = choice;
     }
 
diff --git a/src/engine/TemplateEngine.ts b/src/engine/TemplateEngine.ts
@@ -6,15 +6,16 @@ import {getTemplater} from "../utility";
 import GenericSuggester from "../gui/GenericSuggester/genericSuggester";
 import {FILE_NUMBER_REGEX} from "../constants";
 import {log} from "../logger/logManager";
+import type {IChoiceExecutor} from "../IChoiceExecutor";
 
 export abstract class TemplateEngine extends QuickAddEngine {
     protected formatter: CompleteFormatter;
     protected readonly templater;
 
-    protected constructor(app: App, protected plugin: QuickAdd) {
+    protected constructor(app: App, protected plugin: QuickAdd, choiceFormatter: IChoiceExecutor) {
         super(app);
         this.templater = getTemplater(app);
-        this.formatter = new CompleteFormatter(app, plugin);
+        this.formatter = new CompleteFormatter(app, plugin, choiceFormatter);
     }
 
     public abstract run(): Promise<void> | Promise<string>;
diff --git a/src/formatters/captureChoiceFormatter.ts b/src/formatters/captureChoiceFormatter.ts
@@ -3,14 +3,15 @@ import type ICaptureChoice from "../types/choices/ICaptureChoice";
 import type {App, TFile} from "obsidian";
 import {log} from "../logger/logManager";
 import type QuickAdd from "../main";
+import type {IChoiceExecutor} from "../IChoiceExecutor";
 
 export class CaptureChoiceFormatter extends CompleteFormatter {
     private choice: ICaptureChoice;
     private file: TFile = null;
     private fileContent: string = "";
 
-    constructor(app: App, plugin: QuickAdd) {
-        super(app, plugin);
+    constructor(app: App, plugin: QuickAdd, choiceExecutor: IChoiceExecutor) {
+        super(app, plugin, choiceExecutor);
     }
 
     public async formatContentWithFile(input: string, choice: ICaptureChoice, fileContent: string, file: TFile): Promise<string> {
diff --git a/src/formatters/completeFormatter.ts b/src/formatters/completeFormatter.ts
@@ -8,11 +8,12 @@ import type QuickAdd from "../main";
 import {SingleMacroEngine} from "../engine/SingleMacroEngine";
 import {SingleTemplateEngine} from "../engine/SingleTemplateEngine";
 import {MarkdownView} from "obsidian";
+import type {IChoiceExecutor} from "../IChoiceExecutor";
 
 export class CompleteFormatter extends Formatter {
     private valueHeader: string;
 
-    constructor(protected app: App, private plugin: QuickAdd) {
+    constructor(protected app: App, private plugin: QuickAdd, protected choiceExecutor: IChoiceExecutor) {
         super();
     }
 
@@ -77,7 +78,7 @@ export class CompleteFormatter extends Formatter {
     }
 
     protected async getMacroValue(macroName: string): Promise<string> {
-        const macroEngine: SingleMacroEngine = new SingleMacroEngine(this.app, this.plugin.settings.macros, this.variables);
+        const macroEngine: SingleMacroEngine = new SingleMacroEngine(this.app, this.plugin, this.plugin.settings.macros, this.choiceExecutor, this.variables);
         const macroOutput = await macroEngine.runAndGetOutput(macroName) ?? "";
 
         Object.keys(macroEngine.params.variables).forEach(key => {
@@ -88,7 +89,7 @@ export class CompleteFormatter extends Formatter {
     }
 
     protected async getTemplateContent(templatePath: string): Promise<string> {
-        return await new SingleTemplateEngine(this.app, this.plugin, templatePath).run();
+        return await new SingleTemplateEngine(this.app, this.plugin, templatePath, this.choiceExecutor).run();
     }
 
     protected async getSelectedText(): Promise<string> {
diff --git a/src/formatters/fileNameDisplayFormatter.ts b/src/formatters/fileNameDisplayFormatter.ts
@@ -10,6 +10,7 @@ export class FileNameDisplayFormatter extends Formatter {
     public async format(input: string): Promise<string> {
         let output: string = input;
 
+        output = await this.replaceMacrosInString(output);
         output = this.replaceDateInString(output);
         output = await this.replaceValueInString(output);
         output = await this.replaceDateVariableInString(output);
diff --git a/src/formatters/formatDisplayFormatter.ts b/src/formatters/formatDisplayFormatter.ts
@@ -52,7 +52,7 @@ export class FormatDisplayFormatter extends Formatter {
 
     protected async getTemplateContent(templatePath: string): Promise<string> {
         try {
-            return await new SingleTemplateEngine(this.app, this.plugin, templatePath).run();
+            return await new SingleTemplateEngine(this.app, this.plugin, templatePath, null).run();
         }
         catch (e) {
             return `Template (not found): ${templatePath}`;
diff --git a/src/gui/MacroBuilder.ts b/src/gui/MacroBuilder.ts
diff --git a/src/gui/choiceList/ChoiceView.svelte b/src/gui/choiceList/ChoiceView.svelte
diff --git a/src/gui/choiceSuggester.ts b/src/gui/choiceSuggester.ts
diff --git a/src/main.ts b/src/main.ts
diff --git a/src/types/macros/ChoiceCommand.ts b/src/types/macros/ChoiceCommand.ts
diff --git a/src/types/macros/CommandType.ts b/src/types/macros/CommandType.ts
diff --git a/src/types/macros/IChoiceCommand.ts b/src/types/macros/IChoiceCommand.ts
diff --git a/versions.json b/versions.json

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`{`
`2`	`2`	`"id": "quickadd",`
`3`	`3`	`"name": "QuickAdd",`
`4`		`- "version": "0.2.0",`
	`4`	`+ "version": "0.2.1",`
`5`	`5`	`"minAppVersion": "0.12.00",`
`6`	`6`	`"description": "Quickly add new pages or content to your vault.",`
`7`	`7`	`"author": "Christian B. B. Houmann",`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "quickadd",`
`3`		`- "version": "0.2.0",`
	`3`	`+ "version": "0.2.1",`
`4`	`4`	`"description": "Quickly add new pages or content to your vault.",`
`5`	`5`	`"main": "main.js",`
`6`	`6`	`"scripts": {`