@abreen/tada 1.0.0

package/webpack/utils/content-files.js

@@ -0,0 +1,147 @@
+const fs = require('fs');
+const path = require('path');
+const { parseFrontMatterAndContent } = require('./front-matter');
+const {
+  PUBLIC_ASSET_EXTENSIONS,
+  extensionIsMarkdown,
+  isLiterateJava,
+} = require('./file-types');
+const { getPublicDir, normalizeOutputPath } = require('./paths');
+
+function walkFiles(dir) {
+  return fs.readdirSync(dir).flatMap(file => {
+    const fullPath = path.join(dir, file);
+    if (fs.statSync(fullPath).isDirectory()) {
+      return walkFiles(fullPath);
+    }
+    return [fullPath];
+  });
+}
+
+function getContentFiles(contentDir, codeExtensions) {
+  const extensions = ['md', 'html', 'pdf', ...codeExtensions];
+  const pattern = new RegExp(`\\.(${extensions.join('|')})$`);
+
+  return walkFiles(contentDir).filter(filePath => {
+    return pattern.test(path.basename(filePath));
+  });
+}
+
+function shouldSkipContentFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  if (!(extensionIsMarkdown(ext) || ext === '.html')) {
+    return false;
+  }
+
+  const raw = fs.readFileSync(filePath, 'utf-8');
+  const { pageVariables } = parseFrontMatterAndContent(raw, ext);
+  return pageVariables?.skip === true;
+}
+
+function getBuildContentFiles(contentDir, codeExtensions) {
+  return getContentFiles(contentDir, codeExtensions).filter(
+    filePath => !shouldSkipContentFile(filePath),
+  );
+}
+
+function addGeneratedRouteAliases(pathSet, outputPath) {
+  const normalizedPath = normalizeOutputPath(outputPath);
+  pathSet.add(normalizedPath);
+
+  if (!normalizedPath.endsWith('/index.html')) {
+    return;
+  }
+
+  const base = normalizedPath.slice(0, -'index.html'.length);
+  pathSet.add(base);
+  if (base.endsWith('/') && base.length > 1) {
+    pathSet.add(base.slice(0, -1));
+  }
+}
+
+function getPublicFiles(publicDir) {
+  if (!fs.existsSync(publicDir)) {
+    return [];
+  }
+
+  return walkFiles(publicDir);
+}
+
+function getFilesByExtensions(rootDir, extensions) {
+  if (!fs.existsSync(rootDir)) {
+    return [];
+  }
+
+  const extensionSet = new Set(extensions.map(ext => ext.toLowerCase()));
+
+  return walkFiles(rootDir).filter(filePath => {
+    const ext = path.extname(filePath).slice(1).toLowerCase();
+    return extensionSet.has(ext);
+  });
+}
+
+function getValidInternalTargets(contentDir, contentFiles, codeExtensions) {
+  const targets = new Set();
+  const codeExtensionSet = new Set(
+    codeExtensions.map(ext => ext.toLowerCase()),
+  );
+  const contentAssetExtensionSet = new Set(PUBLIC_ASSET_EXTENSIONS);
+
+  for (const filePath of contentFiles) {
+    const relPath = path.relative(contentDir, filePath);
+    const parsed = path.parse(relPath);
+    const ext = parsed.ext.toLowerCase();
+    const subPath = path
+      .join(parsed.dir, parsed.name)
+      .split(path.sep)
+      .join(path.posix.sep);
+
+    if (isLiterateJava(filePath)) {
+      const baseName = path.parse(parsed.name).name;
+      const literateSubPath = path
+        .join(parsed.dir, baseName)
+        .split(path.sep)
+        .join(path.posix.sep);
+      addGeneratedRouteAliases(targets, `/${literateSubPath}.html`);
+      targets.add(
+        normalizeOutputPath(
+          `/${path.join(parsed.dir, parsed.name).split(path.sep).join(path.posix.sep)}`,
+        ),
+      );
+    } else if (extensionIsMarkdown(ext) || ext === '.html') {
+      addGeneratedRouteAliases(targets, `/${subPath}.html`);
+    } else if (ext === '.pdf') {
+      targets.add(normalizeOutputPath(`/${relPath}`));
+    } else if (codeExtensionSet.has(ext.slice(1))) {
+      addGeneratedRouteAliases(targets, `/${subPath}.html`);
+      targets.add(normalizeOutputPath(`/${relPath}`));
+    } else if (contentAssetExtensionSet.has(ext.slice(1))) {
+      targets.add(normalizeOutputPath(`/${relPath}`));
+    }
+  }
+
+  // Include non-page assets in content/ that are copied directly to dist/.
+  for (const filePath of getFilesByExtensions(
+    contentDir,
+    PUBLIC_ASSET_EXTENSIONS,
+  )) {
+    const relPath = path.relative(contentDir, filePath);
+    targets.add(normalizeOutputPath(`/${relPath}`));
+  }
+
+  const publicDir = getPublicDir();
+  for (const filePath of getPublicFiles(publicDir)) {
+    const relPath = path.relative(publicDir, filePath);
+    targets.add(normalizeOutputPath(`/${relPath}`));
+  }
+
+  return targets;
+}
+
+module.exports = {
+  extensionIsMarkdown,
+  getBuildContentFiles,
+  getContentFiles,
+  getValidInternalTargets,
+  shouldSkipContentFile,
+};

package/webpack/utils/define-plugin.js

@@ -0,0 +1,20 @@
+const { DefinePlugin } = require('webpack');
+
+function createDefinePlugin(siteVariables, isDev = false) {
+  return new DefinePlugin({
+    'window.siteVariables.base': JSON.stringify(siteVariables.base),
+    'window.siteVariables.basePath': JSON.stringify(siteVariables.basePath),
+    'window.siteVariables.titlePostfix': JSON.stringify(
+      siteVariables.titlePostfix,
+    ),
+    'window.siteVariables.defaultTimeZone': JSON.stringify(
+      siteVariables.defaultTimeZone,
+    ),
+    'window.siteVariables.timezones': JSON.stringify(
+      require('../../src/timezone/timezones.json'),
+    ),
+    'window.IS_DEV': JSON.stringify(isDev),
+  });
+}
+
+module.exports = { createDefinePlugin };

package/webpack/utils/file-types.js

@@ -0,0 +1,26 @@
+const path = require('path');
+
+const PUBLIC_ASSET_EXTENSIONS = [
+  'png',
+  'jpg',
+  'jpeg',
+  'gif',
+  'svg',
+  'txt',
+  'zip',
+  'pdf',
+];
+
+function extensionIsMarkdown(ext) {
+  return ['.md', '.markdown'].includes(ext);
+}
+
+function isLiterateJava(filePath) {
+  return path.basename(filePath).toLowerCase().endsWith('.java.md');
+}
+
+module.exports = {
+  PUBLIC_ASSET_EXTENSIONS,
+  extensionIsMarkdown,
+  isLiterateJava,
+};

package/webpack/utils/front-matter.js

@@ -0,0 +1,57 @@
+const fm = require('front-matter');
+const { extensionIsMarkdown } = require('./file-types');
+
+function parseFrontMatterAndContent(raw, ext) {
+  const { frontMatter, content } = parseFrontMatter(raw, ext);
+
+  // Add delimiters to satisfy the front-matter library
+  const result = fm(`---\n${frontMatter}\n---\n`);
+
+  return { pageVariables: result.attributes, content };
+}
+
+function parseFrontMatterPlainText(rawContent) {
+  const lines = rawContent.split(/\r?\n/);
+  const fmLines = [];
+  let i = 0;
+
+  while (i < lines.length) {
+    const line = lines[i];
+
+    if (!line.trim()) {
+      break;
+    } // stop at first completely blank line
+
+    fmLines.push(line);
+
+    // Handle YAML multi-line | syntax
+    if (line.match(/:\s*\|$/)) {
+      i++;
+      while (i < lines.length && /^\s+/.test(lines[i])) {
+        fmLines.push(lines[i++]);
+      }
+      continue;
+    }
+
+    i++;
+  }
+
+  if (fmLines.length === 0) {
+    return { frontMatter: null, content: rawContent };
+  }
+  return {
+    frontMatter: fmLines.join('\n'),
+    content: lines.slice(i).join('\n'),
+  };
+}
+
+function parseFrontMatter(rawContent, ext) {
+  if (extensionIsMarkdown(ext) || ext === '.html') {
+    return parseFrontMatterPlainText(rawContent);
+  } else {
+    // unknown type, return raw
+    return { frontMatter: null, content: rawContent };
+  }
+}
+
+module.exports = { parseFrontMatter, parseFrontMatterAndContent };

package/webpack/utils/jdi-runner/LiterateRunner.java

@@ -0,0 +1,241 @@
+import com.sun.jdi.*;
+import com.sun.jdi.connect.*;
+import com.sun.jdi.event.*;
+import com.sun.jdi.request.*;
+import java.io.*;
+import java.util.*;
+
+/**
+ * Runs a Java class under JDI, stepping through main() line by line and
+ * capturing stdout output per code block.
+ *
+ * Usage: java LiterateRunner <className> <classPath> <blockRangesJSON>
+ *
+ * blockRangesJSON is a JSON array of [startLine, endLine] pairs, e.g.:
+ *   [[1,3],[5,10],[12,18]]
+ *
+ * Outputs a JSON array of [blockIndex, outputString] pairs to stdout.
+ */
+public class LiterateRunner {
+
+    private static int[][] parseBlockRanges(String json) {
+        json = json.trim();
+        if (json.startsWith("'") || json.startsWith("\"")) {
+            json = json.substring(1, json.length() - 1);
+        }
+        json = json.substring(1, json.length() - 1);
+
+        var ranges = new ArrayList<int[]>();
+        int i = 0;
+        while (i < json.length()) {
+            if (json.charAt(i) == '[') {
+                int close = json.indexOf(']', i);
+                String pair = json.substring(i + 1, close);
+                String[] parts = pair.split(",");
+                ranges.add(new int[] {
+                        Integer.parseInt(parts[0].trim()),
+                        Integer.parseInt(parts[1].trim())
+                });
+                i = close + 1;
+            } else {
+                i++;
+            }
+        }
+
+        return ranges.toArray(new int[0][]);
+    }
+
+    private static int findBlock(int[][] ranges, int lineNumber) {
+        for (int i = 0; i < ranges.length; i++) {
+            if (lineNumber >= ranges[i][0] && lineNumber <= ranges[i][1]) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    private static String drainStream(InputStream stream) throws IOException {
+        var sb = new StringBuilder();
+        while (stream.available() > 0) {
+            sb.append((char) stream.read());
+        }
+        return sb.toString();
+    }
+
+    public static void main(String[] args) throws Exception {
+        if (args.length < 3) {
+            System.err.println("Usage: java LiterateRunner <className> <classPath> <blockRangesJSON>");
+            System.exit(1);
+        }
+
+        String className = args[0];
+        String classPath = args[1];
+        int[][] blockRanges = parseBlockRanges(args[2]);
+
+        var blockOutput = new LinkedHashMap<Integer, StringBuilder>();
+
+        // Launch the target VM
+        LaunchingConnector connector = Bootstrap.virtualMachineManager().defaultConnector();
+        Map<String, Connector.Argument> connArgs = connector.defaultArguments();
+        connArgs.get("main").setValue(className);
+        connArgs.get("options").setValue("-cp " + classPath);
+
+        VirtualMachine vm = connector.launch(connArgs);
+        Process process = vm.process();
+        InputStream targetStdout = process.getInputStream();
+        InputStream targetStderr = process.getErrorStream();
+
+        // Drain stderr in a background thread
+        Thread stderrThread = new Thread(() -> {
+            try {
+                targetStderr.transferTo(System.err);
+            } catch (IOException ignored) {
+            }
+        });
+        stderrThread.setDaemon(true);
+        stderrThread.start();
+
+        int activeBlock = -1;
+
+        try {
+            // Set up class prepare request
+            ClassPrepareRequest classPrepareReq = vm.eventRequestManager().createClassPrepareRequest();
+            classPrepareReq.addClassFilter(className);
+            classPrepareReq.setSuspendPolicy(EventRequest.SUSPEND_ALL);
+            classPrepareReq.enable();
+
+            // Process the initial VMStartEvent, then resume
+            EventSet startSet = vm.eventQueue().remove();
+            startSet.resume();
+
+            EventQueue eventQueue = vm.eventQueue();
+            boolean running = true;
+
+            while (running) {
+                EventSet eventSet = eventQueue.remove();
+
+                for (Event event : eventSet) {
+                    if (event instanceof ClassPrepareEvent cpe) {
+                        ReferenceType refType = cpe.referenceType();
+
+                        // Find main method using only declared methods
+                        Method mainMethod = null;
+                        for (Method m : refType.methods()) {
+                            if (m.name().equals("main") && m.returnTypeName().equals("void")) {
+                                var argTypes = m.argumentTypeNames();
+                                if (argTypes.isEmpty() ||
+                                        (argTypes.size() == 1 && argTypes.get(0).equals("java.lang.String[]"))) {
+                                    mainMethod = m;
+                                    break;
+                                }
+                            }
+                        }
+
+                        if (mainMethod != null) {
+                            List<Location> locations = mainMethod.allLineLocations();
+                            if (!locations.isEmpty()) {
+                                BreakpointRequest bp = vm.eventRequestManager()
+                                        .createBreakpointRequest(locations.get(0));
+                                bp.setSuspendPolicy(EventRequest.SUSPEND_ALL);
+                                bp.enable();
+                            }
+                        }
+
+                        classPrepareReq.disable();
+
+                    } else if (event instanceof BreakpointEvent bpe) {
+                        ThreadReference thread = bpe.thread();
+                        int line = bpe.location().lineNumber();
+                        activeBlock = findBlock(blockRanges, line);
+
+                        StepRequest stepReq = vm.eventRequestManager().createStepRequest(
+                                thread, StepRequest.STEP_LINE, StepRequest.STEP_OVER);
+                        stepReq.addClassFilter(className);
+                        stepReq.setSuspendPolicy(EventRequest.SUSPEND_ALL);
+                        stepReq.enable();
+
+                        bpe.request().disable();
+
+                    } else if (event instanceof StepEvent se) {
+                        Thread.sleep(1);
+                        String output = drainStream(targetStdout);
+                        if (!output.isEmpty() && activeBlock >= 0) {
+                            blockOutput.computeIfAbsent(activeBlock, k -> new StringBuilder())
+                                    .append(output);
+                        }
+
+                        int line = se.location().lineNumber();
+                        int newBlock = findBlock(blockRanges, line);
+                        if (newBlock >= 0) {
+                            activeBlock = newBlock;
+                        }
+
+                    } else if (event instanceof VMDeathEvent || event instanceof VMDisconnectEvent) {
+                        Thread.sleep(10);
+                        String output = drainStream(targetStdout);
+                        if (!output.isEmpty() && activeBlock >= 0) {
+                            blockOutput.computeIfAbsent(activeBlock, k -> new StringBuilder())
+                                    .append(output);
+                        }
+                        running = false;
+                    }
+                }
+
+                if (running) {
+                    eventSet.resume();
+                }
+            }
+        } catch (VMDisconnectedException e) {
+            // VM died unexpectedly — drain any remaining output
+            Thread.sleep(10);
+            String output = drainStream(targetStdout);
+            if (!output.isEmpty() && activeBlock >= 0) {
+                blockOutput.computeIfAbsent(activeBlock, k -> new StringBuilder())
+                        .append(output);
+            }
+        } finally {
+            try {
+                vm.dispose();
+            } catch (VMDisconnectedException ignored) {
+            }
+            stderrThread.join(1000);
+        }
+
+        // Output JSON to our own stdout
+        var sb = new StringBuilder();
+        sb.append('[');
+        boolean first = true;
+        for (var entry : blockOutput.entrySet()) {
+            if (!first)
+                sb.append(',');
+            first = false;
+            sb.append('[');
+            sb.append(entry.getKey());
+            sb.append(',');
+            sb.append(jsonEscape(entry.getValue().toString()));
+            sb.append(']');
+        }
+        sb.append(']');
+
+        System.out.print(sb.toString());
+    }
+
+    private static String jsonEscape(String s) {
+        var sb = new StringBuilder();
+        sb.append('"');
+        for (int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+            switch (c) {
+                case '"' -> sb.append("\\\"");
+                case '\\' -> sb.append("\\\\");
+                case '\n' -> sb.append("\\n");
+                case '\r' -> sb.append("\\r");
+                case '\t' -> sb.append("\\t");
+                default -> sb.append(c);
+            }
+        }
+        sb.append('"');
+        return sb.toString();
+    }
+
+}

package/webpack/utils/literate-java.js

@@ -0,0 +1,153 @@
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execSync } = require('child_process');
+const { createMarkdown } = require('./markdown');
+const { makeLogger } = require('../log');
+const { parseFrontMatterAndContent } = require('./front-matter');
+
+const log = makeLogger(__filename);
+
+const MAIN_PATTERN = /\bvoid\s+main\s*\(/m;
+
+function parseLiterateJava(rawContent, siteVariables) {
+  const { pageVariables, content } = parseFrontMatterAndContent(
+    rawContent,
+    '.md',
+  );
+
+  const md = createMarkdown(siteVariables, {
+    validatorOptions: { enabled: false },
+  });
+  const tokens = md.parse(content, {});
+
+  const codeBlocks = [];
+  let javaLine = 1;
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i];
+    if (token.type !== 'fence' && token.type !== 'hidden_fence') {
+      continue;
+    }
+
+    const code = token.content;
+    const codeLines = code.endsWith('\n')
+      ? code.slice(0, -1).split('\n')
+      : code.split('\n');
+    const javaStartLine = javaLine;
+    const javaEndLine = javaLine + codeLines.length - 1;
+    javaLine = javaEndLine + 1;
+
+    const hidden = token.type === 'hidden_fence';
+    codeBlocks.push({ javaStartLine, javaEndLine, content: code, hidden });
+  }
+
+  const javaSource = codeBlocks.map(b => b.content).join('');
+  const visibleBlockIndices = codeBlocks
+    .map((b, i) => (b.hidden ? null : i))
+    .filter(i => i !== null);
+
+  const hiddenCount = codeBlocks.length - visibleBlockIndices.length;
+  log.debug`Parsed ${codeBlocks.length} code block(s) (${hiddenCount} hidden), ${javaSource.split('\n').length} Java line(s)`;
+
+  return {
+    pageVariables,
+    content,
+    javaSource,
+    codeBlocks,
+    visibleBlockIndices,
+  };
+}
+
+function hasMainMethod(javaSource) {
+  return MAIN_PATTERN.test(javaSource);
+}
+
+function deriveClassName(filePath) {
+  const name = path.parse(filePath).name;
+  return path.parse(name).name;
+}
+
+function compileJavaSource(javaSource, className) {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tada-literate-'));
+  const javaFile = path.join(tempDir, `${className}.java`);
+  fs.writeFileSync(javaFile, javaSource);
+
+  log.debug`Compiling ${className}.java (${javaSource.split('\n').length} lines) in ${tempDir}`;
+
+  try {
+    execSync(`javac "${className}.java"`, {
+      cwd: tempDir,
+      timeout: 30000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+  } catch (err) {
+    const stderr = err.stderr ? err.stderr.toString() : err.message;
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    throw new Error(`Compilation failed for ${className}.java:\n${stderr}`);
+  }
+
+  return tempDir;
+}
+
+function ensureRunnerCompiled(runnerDir) {
+  const sourceFile = path.join(runnerDir, 'LiterateRunner.java');
+  const classFile = path.join(runnerDir, 'LiterateRunner.class');
+
+  if (
+    fs.existsSync(classFile) &&
+    fs.statSync(classFile).mtimeMs >= fs.statSync(sourceFile).mtimeMs
+  ) {
+    log.debug`LiterateRunner.class is up to date`;
+    return;
+  }
+
+  log.debug`Compiling LiterateRunner.java`;
+
+  try {
+    execSync('javac LiterateRunner.java', {
+      cwd: runnerDir,
+      timeout: 30000,
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+  } catch (err) {
+    const stderr = err.stderr ? err.stderr.toString() : err.message;
+    throw new Error(`Failed to compile LiterateRunner.java:\n${stderr}`);
+  }
+}
+
+function executeLiterateJava(className, classPath, codeBlocks) {
+  const runnerDir = path.join(__dirname, 'jdi-runner');
+  ensureRunnerCompiled(runnerDir);
+
+  const blockRanges = codeBlocks.map(b => [b.javaStartLine, b.javaEndLine]);
+  const rangesJson = JSON.stringify(blockRanges);
+
+  log.info`Executing literate Java: ${className}`;
+
+  log.debug`Running LiterateRunner with ${blockRanges.length} block range(s)`;
+
+  try {
+    const result = execSync(
+      `java -cp "${runnerDir}" LiterateRunner "${className}" "${classPath}" '${rangesJson}'`,
+      { timeout: 30000, encoding: 'utf-8' },
+    );
+    const entries = JSON.parse(result);
+    log.debug`LiterateRunner returned ${entries.length} output entries`;
+    return entries;
+  } catch (err) {
+    const stderr = err.stderr ? err.stderr.toString() : '';
+    const stdout = err.stdout ? err.stdout.toString() : '';
+    throw new Error(
+      `Execution failed for ${className}:\n${stderr || stdout || err.message}`,
+    );
+  }
+}
+
+module.exports = {
+  parseLiterateJava,
+  hasMainMethod,
+  deriveClassName,
+  compileJavaSource,
+  executeLiterateJava,
+};