@doccident/doccident 0.0.3 → 0.0.5

package/dist/languages/rust.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rustHandler = void 0;
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const rustHandler = (code, _snippet, config, sandbox, isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    const context = sandbox;
+    let rustCode = code;
+    // Handle shared state
+    if (isSharedSandbox) {
+        if (!context._rustCode) {
+            context._rustCode = "";
+        }
+        context._rustCode += code + "\n";
+        rustCode = context._rustCode;
+    }
+    let finalSource = "";
+    // Parse attributes vs body
+    // We want to lift crate-level attributes (#![...]) to the top
+    // Everything else goes inside main
+    // Check if code already has fn main() at the top level?
+    // If users provide a full program with main(), wrapping it in another main is weird but valid.
+    // However, for shared state, we generally assume "script mode".
+    // If not shared, we stick to the old logic (check for main, if not present wrap).
+    if (!isSharedSandbox) {
+        if (!rustCode.includes('fn main()')) {
+            finalSource = `fn main() {
+${rustCode}
+}`;
+        }
+        else {
+            finalSource = rustCode;
+        }
+    }
+    else {
+        // Shared state mode
+        const lines = rustCode.split('\n');
+        const attributes = [];
+        const body = [];
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (trimmed.startsWith('#![') || trimmed.startsWith('extern crate ')) {
+                attributes.push(line);
+            }
+            else {
+                body.push(line);
+            }
+        }
+        finalSource = `${attributes.join('\n')}
+
+fn main() {
+${body.join('\n')}
+}`;
+    }
+    const uniqueId = `${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    const tempSourceFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_rust_${uniqueId}.rs`);
+    const tempExeFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_rust_${uniqueId}`);
+    const timeout = config.timeout || 30000;
+    try {
+        (0, fs_1.writeFileSync)(tempSourceFile, finalSource);
+        // Compile
+        const compileResult = (0, child_process_1.spawnSync)('rustc', [tempSourceFile, '-o', tempExeFile], { encoding: 'utf-8', timeout });
+        if (compileResult.status !== 0) {
+            stack = compileResult.stderr || "Rust compilation failed";
+            if (isSharedSandbox) {
+                stack += `\n\nGenerated Source:\n${finalSource}`;
+            }
+        }
+        else {
+            // Run
+            const runResult = (0, child_process_1.spawnSync)(tempExeFile, [], { encoding: 'utf-8', timeout });
+            if (runResult.error && runResult.error.code === 'ETIMEDOUT') {
+                return { success: false, stack: `Execution timed out after ${timeout}ms` };
+            }
+            if (runResult.status === 0) {
+                success = true;
+            }
+            else {
+                stack = runResult.stderr || "Rust execution failed with non-zero exit code";
+            }
+            return { success, stack, output: runResult.stdout };
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to execute rustc or run binary";
+    }
+    finally {
+        try {
+            if ((0, fs_1.existsSync)(tempSourceFile))
+                (0, fs_1.unlinkSync)(tempSourceFile);
+            if ((0, fs_1.existsSync)(tempExeFile))
+                (0, fs_1.unlinkSync)(tempExeFile);
+        }
+        catch {
+            // Ignore cleanup error
+        }
+    }
+    return { success, stack };
+};
+exports.rustHandler = rustHandler;

package/dist/languages/shell.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.shellHandler = void 0;
+const child_process_1 = require("child_process");
+const shellHandler = (code, snippet, config, sandbox, isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    const context = sandbox;
+    const shell = snippet.language || 'bash';
+    // If sharing code, we need to accumulate previous shell snippets
+    if (isSharedSandbox) {
+        if (!context._shellContext) {
+            context._shellContext = {};
+        }
+        if (!context._shellContext[shell]) {
+            context._shellContext[shell] = "";
+        }
+        context._shellContext[shell] += code + "\n";
+        code = context._shellContext[shell];
+    }
+    try {
+        const args = snippet.args || [];
+        const env = snippet.env ? { ...process.env, ...snippet.env } : undefined;
+        // Use the detected shell
+        // shell -s arg1 arg2 reads from stdin and passes args
+        const spawnArgs = ['-s', ...args];
+        const timeout = config.timeout || 30000;
+        const result = (0, child_process_1.spawnSync)(shell, spawnArgs, { input: code, encoding: 'utf-8', env, timeout });
+        if (result.error && result.error.code === 'ETIMEDOUT') {
+            return { success: false, stack: `Execution timed out after ${timeout}ms` };
+        }
+        if (result.status === 0) {
+            success = true;
+        }
+        else {
+            const exitCode = result.status !== null ? result.status : 'signal';
+            stack = result.stderr || result.stdout || `${shell} execution failed with non-zero exit code: ${exitCode}`;
+        }
+        return { success, stack, output: result.stdout };
+    }
+    catch (e) {
+        stack = e.message || `Failed to spawn ${shell}`;
+        return { success, stack };
+    }
+};
+exports.shellHandler = shellHandler;

package/dist/parse-code-snippets-from-markdown.js

@@ -1,15 +1,75 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const isStartOfSnippet = (line) => line.trim().match(/```\W*(JavaScript|js|es6|ts|typescript)\s?$/i);
+// Capture indentation (group 1) and language (group 2)
+const START_REGEX = /^(\s*)```\W*(JavaScript|js|es6|ts|typescript|python|py|bash|sh|zsh|shell|go|rust|rs|fortran|f90|f95|cobol|cob|c|basic|java|perl|pl|csharp|cs|r|pascal|pas|text|txt|output)\s?$/i;
+const isStartOfSnippet = (line) => line.match(START_REGEX);
 const isEndOfSnippet = (line) => line.trim() === "```";
 const isSkip = (line) => line.trim() === "<!-- skip-example -->";
 const isCodeSharedInFile = (line) => line.trim() === "<!-- share-code-between-examples -->";
-function startNewSnippet(snippets, fileName, lineNumber) {
+const isId = (line) => line.match(/^<!--\s*id:\s*(\S+)\s*-->$/);
+const isOutputOf = (line) => line.match(/^<!--\s*output:\s*(\S+)(?:\s+(match:regex|match:fuzzy|ignore-whitespace))?\s*-->$/);
+const isArgs = (line) => line.match(/^<!--\s*args:\s*(.+)\s*-->$/);
+const isEnv = (line) => line.match(/^<!--\s*env:\s*(.+)\s*-->$/);
+function startNewSnippet(snippets, fileName, lineNumber, language, indentation) {
     const skip = snippets.skip;
     snippets.skip = false;
+    const id = snippets.id;
+    snippets.id = undefined;
+    const outputOf = snippets.outputOf;
+    snippets.outputOf = undefined;
+    const outputMode = snippets.outputMode;
+    snippets.outputMode = undefined;
+    const args = snippets.args;
+    snippets.args = undefined;
+    const env = snippets.env;
+    snippets.env = undefined;
+    let normalizedLang = 'javascript';
+    const langLower = language.toLowerCase();
+    if (['python', 'py'].includes(langLower)) {
+        normalizedLang = 'python';
+    }
+    else if (['bash', 'sh', 'zsh', 'shell'].includes(langLower)) {
+        normalizedLang = langLower === 'shell' ? 'bash' : langLower;
+    }
+    else if (langLower === 'go') {
+        normalizedLang = 'go';
+    }
+    else if (['rust', 'rs'].includes(langLower)) {
+        normalizedLang = 'rust';
+    }
+    else if (['fortran', 'f90', 'f95'].includes(langLower)) {
+        normalizedLang = 'fortran';
+    }
+    else if (['cobol', 'cob'].includes(langLower)) {
+        normalizedLang = 'cobol';
+    }
+    else if (langLower === 'c') {
+        normalizedLang = 'c';
+    }
+    else if (langLower === 'basic') {
+        normalizedLang = 'basic';
+    }
+    else if (langLower === 'java') {
+        normalizedLang = 'java';
+    }
+    else if (['perl', 'pl'].includes(langLower)) {
+        normalizedLang = 'perl';
+    }
+    else if (['csharp', 'cs'].includes(langLower)) {
+        normalizedLang = 'csharp';
+    }
+    else if (langLower === 'r') {
+        normalizedLang = 'r';
+    }
+    else if (['pascal', 'pas'].includes(langLower)) {
+        normalizedLang = 'pascal';
+    }
+    else if (['text', 'txt', 'output'].includes(langLower)) {
+        normalizedLang = 'text';
+    }
     return Object.assign(snippets, {
         snippets: snippets.snippets.concat([
-            { code: "", fileName, lineNumber, complete: false, skip: skip ?? false }
+            { code: "", language: normalizedLang, fileName, lineNumber, complete: false, skip: skip ?? false, indentation, id, outputOf, outputMode, args, env }
         ])
     });
 }
@@ -17,15 +77,20 @@ function addLineToLastSnippet(line) {
     return function addLine(snippets) {
         const lastSnippet = snippets.snippets[snippets.snippets.length - 1];
         if (lastSnippet && !lastSnippet.complete) {
-            lastSnippet.code += line + "\n";
+            let lineToAdd = line;
+            if (lastSnippet.indentation && line.startsWith(lastSnippet.indentation)) {
+                lineToAdd = line.slice(lastSnippet.indentation.length);
+            }
+            lastSnippet.code += lineToAdd + "\n";
         }
         return snippets;
     };
 }
-function endSnippet(snippets, _fileName, _lineNumber) {
+function endSnippet(snippets, _fileName, lineNumber) {
     const lastSnippet = snippets.snippets[snippets.snippets.length - 1];
     if (lastSnippet) {
         lastSnippet.complete = true;
+        lastSnippet.endLine = lineNumber;
     }
     return snippets;
 }
@@ -37,9 +102,64 @@ function shareCodeInFile(snippets) {
     snippets.shareCodeInFile = true;
     return snippets;
 }
+function setId(id) {
+    return (snippets) => {
+        snippets.id = id;
+        return snippets;
+    };
+}
+function setOutputOf(id, mode) {
+    return (snippets) => {
+        snippets.outputOf = id;
+        if (mode === 'match:regex') {
+            snippets.outputMode = 'regex';
+        }
+        else if (mode === 'match:fuzzy' || mode === 'ignore-whitespace') {
+            snippets.outputMode = 'ignore-whitespace';
+        }
+        else {
+            snippets.outputMode = 'exact';
+        }
+        return snippets;
+    };
+}
+function setArgs(argsStr) {
+    return (snippets) => {
+        // Simple space splitting, maybe improve for quotes?
+        // Assuming simple space separation for now.
+        // Filter out empty strings that can occur from leading/trailing whitespace
+        snippets.args = argsStr.split(/\s+/).filter(arg => arg.length > 0);
+        return snippets;
+    };
+}
+function setEnv(envStr) {
+    return (snippets) => {
+        const env = {};
+        // Parse KEY=VALUE pairs separated by spaces
+        const pairs = envStr.split(/\s+/);
+        for (const pair of pairs) {
+            const [key, value] = pair.split('=');
+            if (key && value) {
+                env[key] = value;
+            }
+        }
+        snippets.env = env;
+        return snippets;
+    };
+}
 function parseLine(line) {
-    if (isStartOfSnippet(line)) {
-        return startNewSnippet;
+    const argsMatch = isArgs(line);
+    if (argsMatch) {
+        return setArgs(argsMatch[1]);
+    }
+    const envMatch = isEnv(line);
+    if (envMatch) {
+        return setEnv(envMatch[1]);
+    }
+    const startMatch = isStartOfSnippet(line);
+    if (startMatch) {
+        // startMatch[1] is indentation, startMatch[2] is language
+        return (snippets, fileName, lineNumber) => startNewSnippet(snippets, fileName, lineNumber, startMatch[2], startMatch[1]);
     }
     if (isEndOfSnippet(line)) {
         return endSnippet;
@@ -50,6 +170,16 @@ function parseLine(line) {
     if (isCodeSharedInFile(line)) {
         return shareCodeInFile;
     }
+    const idMatch = isId(line);
+    if (idMatch) {
+        // console.log("Found ID:", idMatch[1]);
+        return setId(idMatch[1]);
+    }
+    const outputMatch = isOutputOf(line);
+    if (outputMatch) {
+        // console.log("Found OutputOf:", outputMatch[1], "Mode:", outputMatch[2]);
+        return setOutputOf(outputMatch[1], outputMatch[2]);
+    }
     return addLineToLastSnippet(line);
 }
 function parseCodeSnippets(args) {

package/dist/reporter.js

@@ -27,6 +27,45 @@ function printResults(results) {
     else {
         console.log(chalk_1.default.red("Failed: " + failingCount));
     }
+    // Summary Table
+    console.log("\nSummary Table:");
+    const headers = { lang: 'Language', file: 'File', line: 'Line', status: 'Status', time: 'Time (ms)' };
+    const rows = results.map(r => {
+        return {
+            lang: r.codeSnippet.language || 'text',
+            file: r.codeSnippet.fileName,
+            line: r.codeSnippet.lineNumber.toString(),
+            status: r.status === 'pass' ? '✅' : (r.status === 'skip' ? '⏭️' : '❌'),
+            time: r.executionTime ? r.executionTime.toFixed(2) : '-'
+        };
+    });
+    const widths = {
+        lang: headers.lang.length,
+        file: headers.file.length,
+        line: headers.line.length,
+        status: headers.status.length,
+        time: headers.time.length
+    };
+    rows.forEach(row => {
+        widths.lang = Math.max(widths.lang, row.lang.length);
+        widths.file = Math.max(widths.file, row.file.length);
+        widths.line = Math.max(widths.line, row.line.length);
+        // Emojis are tricky. Let's assume they take 2 visual columns.
+        // '✅'.length is 1, '❌'.length is 1, '⏭️'.length is 2.
+        // We'll trust the string length for now but maybe ensure minimum for status?
+        widths.status = Math.max(widths.status, [...row.status].length);
+        widths.time = Math.max(widths.time, row.time.length);
+    });
+    const padRight = (str, width) => str + ' '.repeat(Math.max(0, width - str.length));
+    const padLeft = (str, width) => ' '.repeat(Math.max(0, width - str.length)) + str;
+    // Header
+    console.log(`| ${padRight(headers.lang, widths.lang)} | ${padRight(headers.file, widths.file)} | ${padLeft(headers.line, widths.line)} | ${padRight(headers.status, widths.status)} | ${padLeft(headers.time, widths.time)} |`);
+    // Separator
+    console.log(`|-${'-'.repeat(widths.lang)}-|-${'-'.repeat(widths.file)}-|-${'-'.repeat(widths.line)}-|-${'-'.repeat(widths.status)}-|-${'-'.repeat(widths.time)}-|`);
+    // Rows
+    rows.forEach(row => {
+        console.log(`| ${padRight(row.lang, widths.lang)} | ${padRight(row.file, widths.file)} | ${padLeft(row.line, widths.line)} | ${padRight(row.status, widths.status)} | ${padLeft(row.time, widths.time)} |`);
+    });
 }
 function printFailure(result) {
     console.log(chalk_1.default.red(`Failed - ${markDownErrorLocation(result)}`));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@doccident/doccident",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "description": "Test all the code in your markdown docs!",
   "main": "dist/doctest.js",
   "files": [
@@ -14,7 +14,8 @@
     "build": "tsc",
     "lint": "eslint .",
     "test": "vitest run",
-    "precommit": "npm run lint && npm run test",
+    "test:readme": "node bin/cmd.js README.md",
+    "precommit": "npm run lint && npm run test && npm run test:readme",
     "clean": "rm -rf dist",
     "prepublishOnly": "npm run clean && npm run build"
   },
@@ -31,7 +32,7 @@
     "Nick Johnstone",
     "Billaud Cipher <BillaudCipher@proton.me>"
   ],
-  "license": "MIT",
+  "license": "Apache-2.0",
   "bugs": {
     "url": "https://github.com/BillaudCipher/doccident/issues"
   },