@abreen/tada 1.13.7 → 1.14.1

package/build/utils/jdi-runner/TraceRunner.java

@@ -3,6 +3,7 @@ import com.sun.jdi.connect.*;
 import com.sun.jdi.event.*;
 import com.sun.jdi.request.*;
 import java.io.*;
+import java.nio.charset.StandardCharsets;
 import java.util.*;
 
 /**
@@ -17,7 +18,10 @@ public class TraceRunner {
 
     private static final Map<Long, String> objectIdMap = new HashMap<>();
     private static long nextObjId = 1;
-    private static Map<String, ObjectReference> previousReachable = new LinkedHashMap<>();
+    private static final List<OutputEvent> outputEvents = new ArrayList<>();
+    private static final Set<String> unnamedClassNames = new HashSet<>();
+
+    private record OutputEvent(String stream, String text) {}
 
     public static void main(String[] args) throws Exception {
         if (args.length < 2) {
@@ -27,6 +31,9 @@ public class TraceRunner {
 
         String className = args[0];
         String classPath = args[1];
+        for (int i = 2; i < args.length; i++) {
+            unnamedClassNames.add(args[i]);
+        }
 
         LaunchingConnector connector =
             Bootstrap.virtualMachineManager().defaultConnector();
@@ -39,27 +46,31 @@ public class TraceRunner {
         InputStream targetStdout = process.getInputStream();
         InputStream targetStderr = process.getErrorStream();
 
-        Thread stderrThread = new Thread(() -> {
-            try {
-                targetStderr.transferTo(System.err);
-            } catch (IOException ignored) {
-            }
-        });
+        Thread stdoutThread = new Thread(() -> readStream("stdout", targetStdout));
+        Thread stderrThread = new Thread(() -> readStream("stderr", targetStderr));
+        stdoutThread.setDaemon(true);
         stderrThread.setDaemon(true);
+        stdoutThread.start();
         stderrThread.start();
 
         try {
-            ClassPrepareRequest cpr =
-                vm.eventRequestManager().createClassPrepareRequest();
+            EventRequestManager requests = vm.eventRequestManager();
+            ClassPrepareRequest cpr = requests.createClassPrepareRequest();
             cpr.addClassFilter(className);
             cpr.setSuspendPolicy(EventRequest.SUSPEND_ALL);
             cpr.enable();
 
+            ExceptionRequest exceptionRequest =
+                requests.createExceptionRequest(null, false, true);
+            exceptionRequest.setSuspendPolicy(EventRequest.SUSPEND_ALL);
+            exceptionRequest.enable();
+
             vm.eventQueue().remove().resume(); // consume VMStartEvent
 
             boolean running = true;
             while (running) {
                 EventSet eventSet = vm.eventQueue().remove();
+                boolean resumed = false;
                 for (Event event : eventSet) {
                     if (event instanceof ClassPrepareEvent cpe) {
                         Method mainMethod = findMainMethod(cpe.referenceType());
@@ -75,7 +86,7 @@ public class TraceRunner {
                         cpr.disable();
 
                     } else if (event instanceof BreakpointEvent bpe) {
-                        emitState(bpe.thread(), targetStdout);
+                        emitState(bpe.thread(), drainOutputEventsJson());
 
                         var step = vm.eventRequestManager().createStepRequest(
                             bpe.thread(),
@@ -91,14 +102,31 @@ public class TraceRunner {
                         bpe.request().disable();
 
                     } else if (event instanceof StepEvent se) {
-                        emitState(se.thread(), targetStdout);
+                        emitState(se.thread(), drainOutputEventsJson());
+
+                    } else if (event instanceof ExceptionEvent ee
+                            && isUserClass(ee.location().declaringType())) {
+                        String initialOutput = drainOutputEventsJson();
+                        String statePrefix = buildStatePrefix(ee.thread());
+                        eventSet.resume();
+                        resumed = true;
+                        waitForVmTermination(vm.eventQueue());
+                        process.waitFor();
+                        stdoutThread.join(1000);
+                        stderrThread.join(1000);
+                        String finalOutput = mergeOutputJson(
+                            initialOutput,
+                            drainOutputEventsJson());
+                        emitState(statePrefix, finalOutput);
+                        running = false;
+                        break;
 
                     } else if (event instanceof VMDeathEvent
                             || event instanceof VMDisconnectEvent) {
                         running = false;
                     }
                 }
-                if (running) {
+                if (running && !resumed) {
                     eventSet.resume();
                 }
             }
@@ -108,6 +136,7 @@ public class TraceRunner {
                 vm.dispose();
             } catch (VMDisconnectedException ignored) {
             }
+            stdoutThread.join(1000);
             stderrThread.join(1000);
         }
     }
@@ -127,10 +156,18 @@ public class TraceRunner {
     }
 
     private static void emitState(ThreadReference thread,
-            InputStream targetStdout) throws Exception {
+            String outputJson) throws Exception {
         Thread.sleep(1);
-        String newStdout = drainStream(targetStdout);
+        emitState(buildStatePrefix(thread), outputJson);
+    }
+
+    private static void emitState(String statePrefix, String outputJson) {
+        System.out.println(statePrefix + outputJson + "}");
+        System.out.flush();
+    }
 
+    private static String buildStatePrefix(ThreadReference thread)
+            throws Exception {
         Location loc = thread.frame(0).location();
         int line = loc.lineNumber();
         String file = loc.sourceName();
@@ -138,30 +175,13 @@ public class TraceRunner {
         var reachable = new LinkedHashMap<String, ObjectReference>();
         String stackJson = serializeStack(thread, reachable);
 
-        // Carry forward objects from the previous step that are still alive.
-        // This keeps in-flight objects (e.g., on the operand stack during
-        // chained constructor calls) visible in the diagram.
-        for (var entry : previousReachable.entrySet()) {
-            if (!reachable.containsKey(entry.getKey())) {
-                try {
-                    if (!entry.getValue().isCollected()) {
-                        reachable.put(entry.getKey(), entry.getValue());
-                    }
-                } catch (Exception ignored) {
-                }
-            }
-        }
-
         String heapJson = serializeHeap(reachable);
-        previousReachable = new LinkedHashMap<>(reachable);
 
-        System.out.println(
-            "{\"line\":" + line
+        return "{\"line\":" + line
             + ",\"file\":\"" + jsonEscape(file)
             + "\",\"stack\":" + stackJson
             + ",\"heap\":" + heapJson
-            + ",\"stdout\":\"" + jsonEscape(newStdout) + "\"}");
-        System.out.flush();
+            + ",\"output\":";
     }
 
     private static String serializeStack(ThreadReference thread,
@@ -191,7 +211,7 @@ public class TraceRunner {
             if (!frame.location().method().isStatic()) {
                 try {
                     ObjectReference thisObj = frame.thisObject();
-                    if (thisObj != null) {
+                    if (thisObj != null && shouldEmitThis(declType)) {
                         sb.append("\"this\":")
                             .append(serializeValue(thisObj, reachable));
                         firstVar = false;
@@ -238,6 +258,25 @@ public class TraceRunner {
         return sb.toString();
     }
 
+    private static boolean shouldEmitThis(ReferenceType type) {
+        if (!unnamedClassNames.contains(type.name())) {
+            return true;
+        }
+        return hasInstanceFields(type);
+    }
+
+    private static boolean hasInstanceFields(ReferenceType type) {
+        try {
+            for (Field field : type.visibleFields()) {
+                if (!field.isStatic()) {
+                    return true;
+                }
+            }
+        } catch (Exception ignored) {
+        }
+        return false;
+    }
+
     private static String serializeValue(Value val,
             Map<String, ObjectReference> reachable) {
         if (val == null) {
@@ -336,6 +375,11 @@ public class TraceRunner {
         }
 
         ReferenceType type = obj.referenceType();
+        String boxedPrimitiveJson = serializeBoxedPrimitive(obj, type);
+        if (boxedPrimitiveJson != null) {
+            return boxedPrimitiveJson;
+        }
+
         if (!isUserClass(type)) {
             // JDK object: show type name and toString value
             try {
@@ -369,6 +413,74 @@ public class TraceRunner {
         return sb.toString();
     }
 
+    private static String serializeBoxedPrimitive(ObjectReference obj,
+            ReferenceType type) {
+        if (!isBoxedPrimitive(type)) {
+            return null;
+        }
+
+        Field valueField = type.fieldByName("value");
+        if (valueField == null) {
+            return null;
+        }
+
+        try {
+            Value value = obj.getValue(valueField);
+            return "{\"type\":\"" + jsonEscape(type.name())
+                + "\",\"value\":" + primitiveJsonLiteral(value) + "}";
+        } catch (Exception ignored) {
+            return null;
+        }
+    }
+
+    private static boolean isBoxedPrimitive(ReferenceType type) {
+        return switch (type.name()) {
+            case "java.lang.Boolean",
+                 "java.lang.Byte",
+                 "java.lang.Character",
+                 "java.lang.Double",
+                 "java.lang.Float",
+                 "java.lang.Integer",
+                 "java.lang.Long",
+                 "java.lang.Short" -> true;
+            default -> false;
+        };
+    }
+
+    private static String primitiveJsonLiteral(Value value) {
+        if (value instanceof BooleanValue v) {
+            return String.valueOf(v.value());
+        }
+        if (value instanceof ByteValue v) {
+            return String.valueOf(v.value());
+        }
+        if (value instanceof CharValue v) {
+            return "\"" + jsonEscape(String.valueOf(v.value())) + "\"";
+        }
+        if (value instanceof DoubleValue v) {
+            double n = v.value();
+            return Double.isFinite(n)
+                ? String.valueOf(n)
+                : "\"" + jsonEscape(String.valueOf(n)) + "\"";
+        }
+        if (value instanceof FloatValue v) {
+            float n = v.value();
+            return Float.isFinite(n)
+                ? String.valueOf(n)
+                : "\"" + jsonEscape(String.valueOf(n)) + "\"";
+        }
+        if (value instanceof IntegerValue v) {
+            return String.valueOf(v.value());
+        }
+        if (value instanceof LongValue v) {
+            return String.valueOf(v.value());
+        }
+        if (value instanceof ShortValue v) {
+            return String.valueOf(v.value());
+        }
+        return "\"" + jsonEscape(String.valueOf(value)) + "\"";
+    }
+
     private static String getObjectId(ObjectReference obj) {
         return objectIdMap.computeIfAbsent(
             obj.uniqueID(), k -> "obj_" + nextObjId++);
@@ -383,14 +495,91 @@ public class TraceRunner {
             && !name.startsWith("com.sun.");
     }
 
-    private static String drainStream(InputStream stream) throws IOException {
-        var sb = new StringBuilder();
-        while (stream.available() > 0) {
-            sb.append((char) stream.read());
+    private static void waitForVmTermination(EventQueue eventQueue)
+            throws InterruptedException {
+        boolean running = true;
+        while (running) {
+            try {
+                EventSet eventSet = eventQueue.remove();
+                for (Event event : eventSet) {
+                    if (event instanceof VMDeathEvent
+                            || event instanceof VMDisconnectEvent) {
+                        running = false;
+                        break;
+                    }
+                }
+                if (running) {
+                    eventSet.resume();
+                }
+            } catch (VMDisconnectedException ignored) {
+                running = false;
+            }
         }
+    }
+
+    private static void readStream(String streamName, InputStream stream) {
+        byte[] buffer = new byte[4096];
+        try {
+            int n;
+            while ((n = stream.read(buffer)) != -1) {
+                String text = new String(buffer, 0, n, StandardCharsets.UTF_8);
+                synchronized (outputEvents) {
+                    if (!outputEvents.isEmpty()
+                            && outputEvents.get(outputEvents.size() - 1)
+                                .stream().equals(streamName)) {
+                        OutputEvent previous =
+                            outputEvents.remove(outputEvents.size() - 1);
+                        outputEvents.add(new OutputEvent(
+                            streamName,
+                            previous.text() + text));
+                    } else {
+                        outputEvents.add(new OutputEvent(streamName, text));
+                    }
+                }
+            }
+        } catch (IOException ignored) {
+        }
+    }
+
+    private static String drainOutputEventsJson() {
+        List<OutputEvent> drained;
+        synchronized (outputEvents) {
+            drained = new ArrayList<>(outputEvents);
+            outputEvents.clear();
+        }
+        return outputEventsJson(drained);
+    }
+
+    private static String outputEventsJson(List<OutputEvent> events) {
+        var sb = new StringBuilder("[");
+        boolean first = true;
+        for (OutputEvent event : events) {
+            if (!first) {
+                sb.append(',');
+            }
+            first = false;
+            sb.append("{\"stream\":\"")
+                .append(event.stream())
+                .append("\",\"text\":\"")
+                .append(jsonEscape(event.text()))
+                .append("\"}");
+        }
+        sb.append(']');
         return sb.toString();
     }
 
+    private static String mergeOutputJson(String first, String second) {
+        if (first.equals("[]")) {
+            return second;
+        }
+        if (second.equals("[]")) {
+            return first;
+        }
+        return first.substring(0, first.length() - 1)
+            + ","
+            + second.substring(1);
+    }
+
     private static String jsonEscape(String s) {
         var sb = new StringBuilder();
         for (int i = 0; i < s.length(); i++) {

package/build/utils/markdown-partials.ts

@@ -0,0 +1,235 @@
+import fs from 'fs';
+import path from 'path';
+import _ from 'lodash';
+import type MarkdownIt from 'markdown-it';
+import type StateCore from 'markdown-it/lib/rules_core/state_core.mjs';
+import type StateBlock from 'markdown-it/lib/rules_block/state_block.mjs';
+import { extensionIsMarkdown, isPartial } from './file-types';
+import { stripHtmlComments } from './html-comments';
+import type { RenderDependencyCollector } from '../types';
+
+const MAX_INCLUDE_DEPTH = 10;
+const PARTIAL_DIRECTIVE_PATTERN = /^\{\{\{([\s\S]*?)\}\}\}$/;
+const ESCAPED_PARTIAL_DIRECTIVE_PATTERN = /^\\\{\{\{[\s\S]*\}\}\}$/;
+const PARTIAL_CONTEXT_STACK_KEY = '__tadaMarkdownPartialContextStack';
+const LOOSE_PARTIAL_LIST_META_KEY = '__tadaLoosePartialList';
+
+interface MarkdownPartialContext {
+  filePath: string;
+  depth: number;
+}
+
+interface MarkdownPartialsEnv {
+  [PARTIAL_CONTEXT_STACK_KEY]?: MarkdownPartialContext[];
+}
+
+export interface MarkdownPartialsOptions {
+  filePath: string;
+  templateParams: Record<string, unknown>;
+  dependencyCollector?: RenderDependencyCollector;
+}
+
+function getLineText(state: StateBlock, line: number): string {
+  const start = state.bMarks[line] + state.tShift[line];
+  const end = state.eMarks[line];
+  return state.src.slice(start, end);
+}
+
+function getCurrentPartialContext(
+  env: MarkdownPartialsEnv,
+  filePath: string,
+): MarkdownPartialContext {
+  const stack = env[PARTIAL_CONTEXT_STACK_KEY];
+  return stack?.[stack.length - 1] ?? { filePath, depth: 0 };
+}
+
+function renderPartialContent(
+  relativePath: string,
+  caller: MarkdownPartialContext,
+  options: MarkdownPartialsOptions,
+): { resolvedPath: string; content: string } {
+  const resolvedPath = path.resolve(
+    path.dirname(caller.filePath),
+    relativePath,
+  );
+
+  if (!fs.existsSync(resolvedPath)) {
+    throw new Error(
+      `${caller.filePath}: partial not found: ${relativePath} (resolved to ${resolvedPath})`,
+    );
+  }
+  if (!isPartial(resolvedPath)) {
+    throw new Error(
+      `${caller.filePath}: partial target must start with "_": ${relativePath}`,
+    );
+  }
+  if (!extensionIsMarkdown(path.extname(resolvedPath).toLowerCase())) {
+    throw new Error(
+      `${caller.filePath}: partial target must be a Markdown file: ${relativePath}`,
+    );
+  }
+
+  options.dependencyCollector?.partials?.add(resolvedPath);
+  if (caller.depth >= MAX_INCLUDE_DEPTH) {
+    throw new Error(
+      `${caller.filePath}: maximum include depth (${MAX_INCLUDE_DEPTH}) exceeded`,
+    );
+  }
+
+  const raw = fs.readFileSync(resolvedPath, 'utf-8');
+  const content = stripHtmlComments(raw);
+
+  try {
+    return {
+      resolvedPath,
+      content: _.template(content)(options.templateParams),
+    };
+  } catch (err) {
+    throw new Error(
+      `${resolvedPath}: Lodash template error in partial: ${(err as Error).message}`,
+      { cause: err },
+    );
+  }
+}
+
+function tokenizePartialContent(
+  state: StateBlock,
+  content: string,
+  context: MarkdownPartialContext,
+): void {
+  const env = state.env as MarkdownPartialsEnv;
+  const stack = (env[PARTIAL_CONTEXT_STACK_KEY] ??= []);
+  stack.push(context);
+  const tokenStart = state.tokens.length;
+
+  try {
+    const childState = new state.md.block.State(
+      content,
+      state.md,
+      state.env,
+      state.tokens,
+    );
+    childState.level = state.level;
+    childState.parentType = state.parentType;
+    childState.tight = state.tight;
+    childState.ddIndent = state.ddIndent;
+    childState.listIndent = state.listIndent;
+
+    state.md.block.tokenize(childState, childState.line, childState.lineMax);
+    if (!childState.tight) {
+      markCurrentListLoose(state, tokenStart);
+    }
+  } finally {
+    stack.pop();
+  }
+}
+
+function markCurrentListLoose(state: StateBlock, tokenStart: number): void {
+  let closedLists = 0;
+  for (let i = tokenStart - 1; i >= 0; i--) {
+    const token = state.tokens[i];
+    if (
+      token.type === 'bullet_list_close' ||
+      token.type === 'ordered_list_close'
+    ) {
+      closedLists++;
+      continue;
+    }
+
+    if (
+      token.type === 'bullet_list_open' ||
+      token.type === 'ordered_list_open'
+    ) {
+      if (closedLists === 0) {
+        token.meta = {
+          ...(token.meta ?? {}),
+          [LOOSE_PARTIAL_LIST_META_KEY]: true,
+        };
+        return;
+      }
+      closedLists--;
+    }
+  }
+}
+
+function restoreLoosePartialLists(state: StateCore): void {
+  const looseListLevels: number[] = [];
+
+  for (const token of state.tokens) {
+    if (
+      token.type === 'bullet_list_open' ||
+      token.type === 'ordered_list_open'
+    ) {
+      if (token.meta?.[LOOSE_PARTIAL_LIST_META_KEY]) {
+        looseListLevels.push(token.level);
+      }
+      continue;
+    }
+
+    if (
+      token.type === 'bullet_list_close' ||
+      token.type === 'ordered_list_close'
+    ) {
+      const listIndex = looseListLevels.lastIndexOf(token.level);
+      if (listIndex !== -1) {
+        looseListLevels.splice(listIndex, 1);
+      }
+      continue;
+    }
+
+    if (token.type !== 'paragraph_open' && token.type !== 'paragraph_close') {
+      continue;
+    }
+
+    if (looseListLevels.some(level => token.level === level + 2)) {
+      token.hidden = false;
+    }
+  }
+}
+
+export default function markdownPartialsPlugin(
+  md: MarkdownIt,
+  options: MarkdownPartialsOptions,
+): void {
+  md.core.ruler.after(
+    'block',
+    'tada_markdown_partial_loose_lists',
+    restoreLoosePartialLists,
+  );
+
+  md.block.ruler.before(
+    'paragraph',
+    'tada_markdown_partial',
+    (state, startLine, _endLine, silent) => {
+      const trimmedLine = getLineText(state, startLine).trim();
+      if (ESCAPED_PARTIAL_DIRECTIVE_PATTERN.test(trimmedLine)) {
+        return false;
+      }
+
+      const match = trimmedLine.match(PARTIAL_DIRECTIVE_PATTERN);
+      if (!match) {
+        return false;
+      }
+
+      if (silent) {
+        return true;
+      }
+
+      const relativePath = match[1].trim();
+      if (!relativePath) {
+        throw new Error(`${options.filePath}: partial path is empty`);
+      }
+
+      const env = state.env as MarkdownPartialsEnv;
+      const caller = getCurrentPartialContext(env, options.filePath);
+      const partial = renderPartialContent(relativePath, caller, options);
+      tokenizePartialContent(state, partial.content, {
+        filePath: partial.resolvedPath,
+        depth: caller.depth + 1,
+      });
+      state.line = startLine + 1;
+      return true;
+    },
+    { alt: ['paragraph', 'reference', 'blockquote', 'list'] },
+  );
+}

package/build/utils/markdown.ts

@@ -18,7 +18,8 @@ import columnsPlugin from '../columns-plugin';
 import markdownItKatex from '@vscode/markdown-it-katex';
 import katex from 'katex';
 import renderA11yString from 'katex/contrib/render-a11y-string';
-import type { SiteVariables } from '../types';
+import markdownPartialsPlugin from './markdown-partials';
+import type { RenderDependencyCollector, SiteVariables } from '../types';
 
 const DETAILS_PATTERN = /^details\s+(.*)$/;
 const ALERT_PATTERN = /^(note|warning)(?:\s+"(.+)"|\s+(.+))?$/;
@@ -31,6 +32,8 @@ interface CreateMarkdownOptions {
   literateJavaOutputPaths?: Set<string>;
   sourceUrlPath?: string;
   validTargets?: Set<string>;
+  templateParams?: Record<string, unknown>;
+  dependencyCollector?: RenderDependencyCollector;
 }
 
 function capitalize(str: string): string {
@@ -102,6 +105,14 @@ export function createMarkdown(
       },
     });
 
+  if (filePath && options.templateParams) {
+    markdown.use(markdownPartialsPlugin, {
+      filePath,
+      templateParams: options.templateParams,
+      dependencyCollector: options.dependencyCollector,
+    });
+  }
+
   function createWrapperToken(
     type: string,
     nesting: -1 | 0 | 1,