feat: Allow embedding block links in inline rant blocks

Author: lanice

src/main.ts

@@ -13,13 +13,15 @@ import {
   CodeblockRantProcessor,
   InlineRantProcessor,
   BaseRantProcessor,
-  Customization,
+  BlockLinkRantProcessor,
+  BLOCK_LINK_REGEX,
 } from "./processor";
 import SettingTab, { DEFAULT_SETTINGS, RantLangSettings } from "./settings";
 
 export default class RantLangPlugin extends Plugin {
   settings: RantLangSettings;
   fileMap: Map<TFile, BaseRantProcessor[]> = new Map();
+  rantBlockStore: Map<string, TFile> = new Map();
 
   async onload() {
     // Load WebAssembly Rust plugin to have access to the Rust Rant crate.
@@ -37,19 +39,12 @@ export default class RantLangPlugin extends Plugin {
         const file = this.app.vault.getAbstractFileByPath(ctx.sourcePath);
         if (!file || !(file instanceof TFile)) return;
 
-        let customizations: Customization[] = [];
-        let lines = source.split("\n");
-        while (lines.length > 0 && ["bold", "italic"].contains(lines[0])) {
-          customizations.push(lines.shift() as Customization);
-        }
-        const input = lines.join("\n");
-
         const processor = new CodeblockRantProcessor(
-          input,
+          this,
+          source,
           el,
           this.settings,
-          ctx.sourcePath,
-          customizations
+          ctx.sourcePath
         );
         ctx.addChild(processor);
 
@@ -69,11 +64,16 @@ export default class RantLangPlugin extends Plugin {
           const codeblock = codeblocks.item(index);
           const text = codeblock.innerText.trim();
           if (text.startsWith(inlineRantQueryPrefix)) {
-            const code = text.substring(inlineRantQueryPrefix.length).trim();
             const container = el.createSpan();
             codeblock.replaceWith(container);
 
-            const processor = new InlineRantProcessor(
+            const code = text.substring(inlineRantQueryPrefix.length).trim();
+            const processorClass = code.match(BLOCK_LINK_REGEX)
+              ? BlockLinkRantProcessor
+              : InlineRantProcessor;
+
+            const processor = new processorClass(
+              this,
               code,
               container,
               this.settings,

src/processor.ts

@@ -1,41 +1,43 @@
-import { MarkdownRenderChild, MarkdownRenderer } from "obsidian";
+import { MarkdownRenderChild, MarkdownRenderer, TFile } from "obsidian";
 import { rant } from "../pkg/obsidian_rantlang_plugin.js";
-import { RantLangSettings } from "./settings.js";
-import { randomSeed } from "./utils.js";
+import type RantLangPlugin from "./main";
+import { RantLangSettings } from "./settings";
+import { randomSeed } from "./utils";
+
+export const BLOCK_LINK_REGEX =
+  /\[\[(?<link>[\s\S]+?)#?\^(?<block>[\s\S]+?)\]\]/;
 
 export abstract class BaseRantProcessor extends MarkdownRenderChild {
   result: string = "";
 
   constructor(
+    public plugin: RantLangPlugin,
     public input: string,
     public container: HTMLElement,
     public settings: RantLangSettings,
-    public sourcePath: string,
-    public customizations: Customization[] = []
+    public sourcePath: string
   ) {
     super(container);
     this.rant();
   }
 
   abstract renderResult(): void;
 
-  processInput(seed: number) {
+  processInput(input: string, seed: number) {
     try {
-      this.result = rant(this.input, seed);
+      this.result = rant(input, seed);
     } catch (error) {
       this.result = "ERROR processing Rant block (see console for details)";
       console.error(error);
     }
   }
 
-  rant(seed?: number) {
-    this.processInput(seed ?? randomSeed());
+  rant(input?: string, seed?: number) {
+    this.processInput(input ?? this.input, seed ?? randomSeed());
     this.renderResult();
   }
 }
 
-export type Customization = "bold" | "italic";
-
 export class CodeblockRantProcessor extends BaseRantProcessor {
   renderResult() {
     this.container.empty();
@@ -53,9 +55,6 @@ export class CodeblockRantProcessor extends BaseRantProcessor {
     if (this.settings.highlight) {
       cls.push("rant-highlight");
     }
-    this.customizations.forEach((style) => {
-      cls.push(`rant-${style}`);
-    });
     return cls;
   }
 }
@@ -83,3 +82,76 @@ export class InlineRantProcessor extends BaseRantProcessor {
     return cls;
   }
 }
+
+export class BlockLinkRantProcessor extends BaseRantProcessor {
+  loaded: boolean = false;
+  path: string;
+  block: string;
+
+  constructor(
+    plugin: RantLangPlugin,
+    input: string,
+    container: HTMLElement,
+    settings: RantLangSettings,
+    sourcePath: string
+  ) {
+    super(plugin, input, container, settings, sourcePath);
+    this.parseBlockLink(input);
+    this.rant();
+  }
+
+  parseBlockLink(blockLink: string) {
+    const { groups } = blockLink.match(BLOCK_LINK_REGEX);
+    this.path = groups.link.replace(/(\[|\])/g, "");
+    this.block = groups.block.replace(/(\^|#)/g, "").trim();
+    this.loaded = true;
+  }
+
+  rant() {
+    if (!this.loaded) {
+      return;
+    }
+
+    const file = this.plugin.app.metadataCache.getFirstLinkpathDest(
+      this.path,
+      this.sourcePath
+    );
+
+    if (!file || !(file instanceof TFile)) {
+      throw new Error("Could not load file.");
+    }
+
+    const cache = this.plugin.app.metadataCache.getFileCache(file);
+    const position = cache.blocks[this.block].position;
+
+    this.plugin.app.vault.cachedRead(file).then((content) => {
+      const rantProgram = content
+        .split("\n")
+        .slice(position.start.line + 1, position.end.line)
+        .join("\n");
+      super.rant(rantProgram);
+    });
+  }
+
+  renderResult() {
+    let temp = createEl("div");
+    MarkdownRenderer.renderMarkdown(this.result, temp, this.sourcePath, this);
+
+    this.container.empty();
+    this.container.className = this.getStyles().join(" ");
+
+    temp.childNodes.forEach((paragraph) => {
+      paragraph.childNodes.forEach((node) => {
+        this.container.appendChild(node.cloneNode(true));
+      });
+    });
+  }
+
+  getStyles() {
+    let cls = ["rant-inline"];
+    if (this.settings.highlight) {
+      cls.push("rant-highlight");
+    }
+    return cls;
+  }
+}

styles.css

@@ -9,11 +9,3 @@
 .rant-highlight.rant-block {
     padding: 0px 8px;
 }
-
-.rant-bold {
-    font-weight: bold;
-}
-
-.rant-italic {
-    font-style: italic;
-}