@doccident/doccident 0.0.2 → 0.0.4

package/dist/doctest.js

@@ -1,57 +1,64 @@
-/* eslint-disable no-console */
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.printResults = void 0;
 exports.runTests = runTests;
-exports.printResults = printResults;
-var fs_1 = require("fs");
-var vm_1 = require("vm");
-var core_1 = require("@babel/core");
-var preset_env_1 = require("@babel/preset-env");
-var chalk_1 = require("chalk");
-function flatten(arr) {
-    return Array.prototype.concat.apply([], arr);
-}
-var parse_code_snippets_from_markdown_1 = require("./parse-code-snippets-from-markdown");
+const fs_1 = require("fs");
+const chalk_1 = __importDefault(require("chalk"));
+const utils_1 = require("./utils");
+const parse_code_snippets_from_markdown_1 = __importDefault(require("./parse-code-snippets-from-markdown"));
+const reporter_1 = require("./reporter");
+Object.defineProperty(exports, "printResults", { enumerable: true, get: function () { return reporter_1.printResults; } });
+const python_1 = require("./languages/python");
+const shell_1 = require("./languages/shell");
+const go_1 = require("./languages/go");
+const rust_1 = require("./languages/rust");
+const fortran_1 = require("./languages/fortran");
+const cobol_1 = require("./languages/cobol");
+const c_1 = require("./languages/c");
+const javascript_1 = require("./languages/javascript");
 function runTests(files, config) {
-    var results = files
+    const results = files
         .map(read)
         .map(parse_code_snippets_from_markdown_1.default)
         .map(testFile(config));
-    return flatten(results);
+    return (0, utils_1.flatten)(results);
 }
 function read(fileName) {
-    return { contents: (0, fs_1.readFileSync)(fileName, "utf8"), fileName: fileName };
+    return { contents: (0, fs_1.readFileSync)(fileName, "utf8"), fileName };
 }
 function makeTestSandbox(config) {
     function sandboxRequire(moduleName) {
-        for (var regexRequire in config.regexRequire) {
-            var regex = new RegExp(regexRequire);
-            var match = regex.exec(moduleName);
-            var handler = config.regexRequire[regexRequire];
+        for (const regexRequire in config.regexRequire) {
+            const regex = new RegExp(regexRequire);
+            const match = regex.exec(moduleName);
+            const handler = config.regexRequire[regexRequire];
             if (match) {
-                return handler.apply(void 0, match);
+                return handler(...match);
             }
         }
-        if (config.require[moduleName] === undefined) {
+        if (config.require === undefined || config.require[moduleName] === undefined) {
             throw moduleNotFoundError(moduleName);
         }
         return config.require[moduleName];
     }
-    var sandboxConsole = {
-        log: function () { return null; },
+    const sandboxConsole = {
+        log: () => null,
     };
-    var sandboxGlobals = { require: sandboxRequire, console: config.testOutput ? console : sandboxConsole };
-    var sandbox = Object.assign({}, sandboxGlobals, config.globals);
+    const sandboxGlobals = { require: sandboxRequire, console: config.testOutput ? console : sandboxConsole };
+    const sandbox = Object.assign({}, sandboxGlobals, config.globals);
     return sandbox;
 }
 function testFile(config) {
     return function testFileWithConfig(args) {
-        var codeSnippets = args.codeSnippets;
-        var fileName = args.fileName;
-        var shareCodeInFile = args.shareCodeInFile;
-        var results;
+        const codeSnippets = args.codeSnippets;
+        const fileName = args.fileName;
+        const shareCodeInFile = args.shareCodeInFile;
+        let results;
         if (shareCodeInFile) {
-            var sandbox = makeTestSandbox(config);
+            const sandbox = makeTestSandbox(config);
             results = codeSnippets.map(test(config, fileName, sandbox));
         }
         else {
@@ -60,99 +67,79 @@ function testFile(config) {
         return results;
     };
 }
-function test(config, filename, sandbox) {
-    return function (codeSnippet) {
+function test(config, _filename, sandbox) {
+    return (codeSnippet) => {
         if (codeSnippet.skip) {
-            return { status: "skip", codeSnippet: codeSnippet, stack: "" };
+            return { status: "skip", codeSnippet, stack: "" };
         }
-        var success = false;
-        var stack = "";
-        var code = codeSnippet.code;
+        let success = false;
+        let stack = "";
+        let code = codeSnippet.code;
         if (config.transformCode) {
             try {
                 code = config.transformCode(code);
             }
             catch (e) {
-                return { status: "fail", codeSnippet: codeSnippet, stack: "Encountered an error while transforming snippet: \n" + e.stack };
+                return { status: "fail", codeSnippet, stack: "Encountered an error while transforming snippet: \n" + e.stack };
             }
         }
-        var perSnippetSandbox;
+        let perSnippetSandbox;
+        let activeSandbox;
+        let isSharedSandbox = false;
         if (sandbox === undefined) {
             perSnippetSandbox = makeTestSandbox(config);
+            activeSandbox = perSnippetSandbox;
+        }
+        else {
+            activeSandbox = sandbox;
+            isSharedSandbox = true;
         }
         if (config.beforeEach) {
             config.beforeEach();
         }
-        var options = {
-            presets: [preset_env_1.default],
-        };
-        try {
-            if (config.babel !== false) {
-                code = (0, core_1.transformSync)(code, options).code;
-            }
-            (0, vm_1.runInNewContext)(code, perSnippetSandbox || sandbox);
-            success = true;
+        let result;
+        if (codeSnippet.language === 'python') {
+            result = (0, python_1.pythonHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (['bash', 'sh', 'zsh'].includes(codeSnippet.language || '')) {
+            result = (0, shell_1.shellHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (codeSnippet.language === 'go') {
+            result = (0, go_1.goHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
         }
-        catch (e) {
-            stack = e.stack || "";
+        else if (codeSnippet.language === 'rust') {
+            result = (0, rust_1.rustHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (codeSnippet.language === 'fortran') {
+            result = (0, fortran_1.fortranHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (codeSnippet.language === 'cobol') {
+            result = (0, cobol_1.cobolHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else if (codeSnippet.language === 'c') {
+            result = (0, c_1.cHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
+        }
+        else {
+            result = (0, javascript_1.javascriptHandler)(code, codeSnippet, config, activeSandbox, isSharedSandbox);
         }
-        var status = success ? "pass" : "fail";
+        success = result.success;
+        stack = result.stack;
+        const status = success ? "pass" : "fail";
         process.stdout.write(success ? chalk_1.default.green(".") : chalk_1.default.red("x"));
-        return { status: status, codeSnippet: codeSnippet, stack: stack };
+        return { status, codeSnippet, stack };
     };
 }
-function printResults(results) {
-    results.filter(function (result) { return result.status === "fail"; }).forEach(printFailure);
-    var passingCount = results.filter(function (result) { return result.status === "pass"; })
-        .length;
-    var failingCount = results.filter(function (result) { return result.status === "fail"; })
-        .length;
-    var skippingCount = results.filter(function (result) { return result.status === "skip"; })
-        .length;
-    function successfulRun() {
-        return failingCount === 0;
-    }
-    console.log(chalk_1.default.green("Passed: " + passingCount));
-    if (skippingCount > 0) {
-        console.log(chalk_1.default.yellow("Skipped: " + skippingCount));
-    }
-    if (successfulRun()) {
-        console.log(chalk_1.default.green("\nSuccess!"));
-    }
-    else {
-        console.log(chalk_1.default.red("Failed: " + failingCount));
-    }
-}
-function printFailure(result) {
-    console.log(chalk_1.default.red("Failed - ".concat(markDownErrorLocation(result))));
-    var stackDetails = relevantStackDetails(result.stack);
-    console.log(stackDetails);
-    var variableNotDefined = stackDetails.match(/(\w+) is not defined/);
-    if (variableNotDefined) {
-        var variableName = variableNotDefined[1];
-        console.log("You can declare ".concat(chalk_1.default.blue(variableName), " in the ").concat(chalk_1.default.blue("globals"), " section in ").concat(chalk_1.default.grey(".doccident-setup.js")));
-        console.log("\nFor example:\n".concat(chalk_1.default.grey("// .doccident-setup.js"), "\nmodule.exports = {\n  globals: {\n    ").concat(chalk_1.default.blue(variableName), ": ...\n  }\n}\n    "));
-    }
-}
-function relevantStackDetails(stack) {
-    var match = stack.match(/([\w\W]*?)at eval/) ||
-        // eslint-disable-next-line no-useless-escape
-        stack.match(/([\w\W]*)at [\w*\/]*?doctest.js/);
-    if (match !== null) {
-        return match[1];
-    }
-    return stack;
-}
 function moduleNotFoundError(moduleName) {
-    return new Error("\nAttempted to require '".concat(chalk_1.default.blue(moduleName), "' but was not found in config.\nYou need to include it in the require section of your ").concat(chalk_1.default.grey(".doccident-setup.js"), " file.\n\nFor example:\n").concat(chalk_1.default.grey("// .doccident-setup.js"), "\nmodule.exports = {\n  require: {\n    ").concat(chalk_1.default.blue("'".concat(moduleName, "': require('").concat(moduleName, "')")), "\n  }\n}\n  "));
+    return new Error(`
+Attempted to require '${chalk_1.default.blue(moduleName)}' but was not found in config.
+You need to include it in the require section of your ${chalk_1.default.grey(".doccident-setup.js")} file.
+
+For example:
+${chalk_1.default.grey("// .doccident-setup.js")}
+module.exports = {
+  require: {
+    ${chalk_1.default.blue(`'${moduleName}': require('${moduleName}')`)}
+  }
 }
-function markDownErrorLocation(result) {
-    var match = result.stack.match(/eval.*<.*>:(\d+):(\d+)/);
-    if (match) {
-        var mdLineNumber = parseInt(match[1], 10);
-        var columnNumber = parseInt(match[2], 10);
-        var lineNumber = result.codeSnippet.lineNumber + mdLineNumber;
-        return "".concat(result.codeSnippet.fileName, ":").concat(lineNumber, ":").concat(columnNumber);
-    }
-    return "".concat(result.codeSnippet.fileName, ":").concat(result.codeSnippet.lineNumber);
+  `);
 }

package/dist/languages/c.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cHandler = 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 cHandler = (code, _snippet, _config, _sandbox, _isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    // C execution logic
+    // Auto-wrap in main function if not present
+    let cCode = code;
+    if (!cCode.includes('main(')) {
+        cCode = `#include <stdio.h>
+ int main() {
+ ${cCode}
+ return 0;
+ }`;
+    }
+    const uniqueId = `${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    const tempSourceFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_c_${uniqueId}.c`);
+    const tempExeFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_c_${uniqueId}`);
+    try {
+        (0, fs_1.writeFileSync)(tempSourceFile, cCode);
+        // Compile with gcc
+        const compileResult = (0, child_process_1.spawnSync)('gcc', [tempSourceFile, '-o', tempExeFile], { encoding: 'utf-8' });
+        if (compileResult.status !== 0) {
+            stack = compileResult.stderr || "C compilation failed";
+        }
+        else {
+            // Run
+            const runResult = (0, child_process_1.spawnSync)(tempExeFile, [], { encoding: 'utf-8' });
+            if (runResult.status === 0) {
+                success = true;
+            }
+            else {
+                stack = runResult.stderr || "C execution failed with non-zero exit code";
+            }
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to execute gcc 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.cHandler = cHandler;

package/dist/languages/cobol.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cobolHandler = 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 cobolHandler = (code, _snippet, _config, _sandbox, _isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    // COBOL execution logic
+    // Use shorter filename as cobc has strict length limits
+    const uniqueId = Math.random().toString(36).substring(2, 10);
+    const tempSourceFile = (0, path_1.join)((0, os_1.tmpdir)(), `cob_${uniqueId}.cob`);
+    const tempExeFile = (0, path_1.join)((0, os_1.tmpdir)(), `cob_${uniqueId}`);
+    try {
+        (0, fs_1.writeFileSync)(tempSourceFile, code);
+        // Compile with cobc -x (executable) -free (free format)
+        const compileResult = (0, child_process_1.spawnSync)('cobc', ['-x', '-free', '-o', tempExeFile, tempSourceFile], { encoding: 'utf-8' });
+        if (compileResult.status !== 0) {
+            stack = compileResult.stderr || "COBOL compilation failed";
+        }
+        else {
+            // Run
+            const runResult = (0, child_process_1.spawnSync)(tempExeFile, [], { encoding: 'utf-8' });
+            if (runResult.status === 0) {
+                success = true;
+            }
+            else {
+                stack = runResult.stderr || "COBOL execution failed with non-zero exit code";
+            }
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to execute cobc 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.cobolHandler = cobolHandler;

package/dist/languages/fortran.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fortranHandler = 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 fortranHandler = (code, _snippet, _config, _sandbox, _isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    // Fortran execution logic
+    // Auto-wrap if 'program' is missing
+    let fortranCode = code;
+    if (!fortranCode.toLowerCase().includes('program ')) {
+        fortranCode = `program main
+ ${fortranCode}
+ end program main`;
+    }
+    const uniqueId = `${Date.now()}_${Math.random().toString(36).substring(7)}`;
+    const tempSourceFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_fortran_${uniqueId}.f90`);
+    const tempExeFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_fortran_${uniqueId}`);
+    try {
+        (0, fs_1.writeFileSync)(tempSourceFile, fortranCode);
+        // Compile with gfortran
+        const compileResult = (0, child_process_1.spawnSync)('gfortran', [tempSourceFile, '-o', tempExeFile], { encoding: 'utf-8' });
+        if (compileResult.status !== 0) {
+            stack = compileResult.stderr || "Fortran compilation failed";
+        }
+        else {
+            // Run
+            const runResult = (0, child_process_1.spawnSync)(tempExeFile, [], { encoding: 'utf-8' });
+            if (runResult.status === 0) {
+                success = true;
+            }
+            else {
+                stack = runResult.stderr || "Fortran execution failed with non-zero exit code";
+            }
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to execute gfortran 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.fortranHandler = fortranHandler;

package/dist/languages/go.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.goHandler = 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 goHandler = (code, _snippet, _config, _sandbox, _isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    // No shared context for Go yet, as it's compiled and strict structure
+    // We support standalone files or body snippets wrapped in main
+    let goCode = code;
+    if (!goCode.includes('package main')) {
+        goCode = `package main
+import "fmt"
+func main() {
+${goCode}
+}`;
+    }
+    const tempFile = (0, path_1.join)((0, os_1.tmpdir)(), `doccident_go_${Date.now()}_${Math.random().toString(36).substring(7)}.go`);
+    try {
+        (0, fs_1.writeFileSync)(tempFile, goCode);
+        const result = (0, child_process_1.spawnSync)('go', ['run', tempFile], { encoding: 'utf-8' });
+        if (result.status === 0) {
+            success = true;
+        }
+        else {
+            stack = result.stderr || "Go execution failed with non-zero exit code";
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to execute go run";
+    }
+    finally {
+        try {
+            (0, fs_1.unlinkSync)(tempFile);
+        }
+        catch {
+            // Ignore cleanup error
+        }
+    }
+    return { success, stack };
+};
+exports.goHandler = goHandler;

package/dist/languages/interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/languages/javascript.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.javascriptHandler = void 0;
+const vm_1 = require("vm");
+const esbuild_1 = require("esbuild");
+const javascriptHandler = (code, _snippet, _config, sandbox, _isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    try {
+        const result = (0, esbuild_1.transformSync)(code, {
+            loader: 'ts',
+            format: 'cjs',
+            target: 'node12'
+        });
+        const compiledCode = result.code || "";
+        (0, vm_1.runInNewContext)(compiledCode, sandbox);
+        success = true;
+    }
+    catch (e) {
+        stack = e.stack || "";
+    }
+    return { success, stack };
+};
+exports.javascriptHandler = javascriptHandler;

package/dist/languages/python.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pythonHandler = void 0;
+const child_process_1 = require("child_process");
+const pythonHandler = (code, _snippet, _config, sandbox, isSharedSandbox) => {
+    let success = false;
+    let stack = "";
+    const context = sandbox;
+    // If sharing code, we need to accumulate previous python snippets
+    if (isSharedSandbox) {
+        if (!context._pythonContext) {
+            context._pythonContext = "";
+        }
+        context._pythonContext += code + "\n";
+        code = context._pythonContext;
+    }
+    try {
+        const result = (0, child_process_1.spawnSync)('python3', [], { input: code, encoding: 'utf-8' });
+        if (result.status === 0) {
+            success = true;
+        }
+        else {
+            stack = result.stderr || "Python execution failed with non-zero exit code";
+        }
+    }
+    catch (e) {
+        stack = e.message || "Failed to spawn python3";
+    }
+    return { success, stack };
+};
+exports.pythonHandler = pythonHandler;

package/dist/languages/rust.js

@@ -0,0 +1,56 @@
+"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 = "";
+    // Rust execution logic
+    // Auto-wrap in main function if not present
+    let rustCode = code;
+    if (!rustCode.includes('fn main()')) {
+        rustCode = `fn main() {
+ ${rustCode}
+ }`;
+    }
+    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}`);
+    try {
+        (0, fs_1.writeFileSync)(tempSourceFile, rustCode);
+        // Compile
+        const compileResult = (0, child_process_1.spawnSync)('rustc', [tempSourceFile, '-o', tempExeFile], { encoding: 'utf-8' });
+        if (compileResult.status !== 0) {
+            stack = compileResult.stderr || "Rust compilation failed";
+        }
+        else {
+            // Run
+            const runResult = (0, child_process_1.spawnSync)(tempExeFile, [], { encoding: 'utf-8' });
+            if (runResult.status === 0) {
+                success = true;
+            }
+            else {
+                stack = runResult.stderr || "Rust execution failed with non-zero exit code";
+            }
+        }
+    }
+    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,37 @@
+"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 {
+        // Use the detected shell
+        const result = (0, child_process_1.spawnSync)(shell, ['-s'], { input: code, encoding: 'utf-8' });
+        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}`;
+        }
+    }
+    catch (e) {
+        stack = e.message || `Failed to spawn ${shell}`;
+    }
+    return { success, stack };
+};
+exports.shellHandler = shellHandler;