Inscribe 0.0.3

A markdown preprocessor that executes code fences and embeds their output.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102

//! Defines configuration structures and default settings for language runners.
//!
//! This module contains the `Runner` struct, which specifies how to execute
//! code for a particular language, and the `default_runners` function, which
//! provides a pre-configured map of common languages to their runners.

use std::collections::HashMap;

/// A constant for the delimiter used to separate outputs from different code blocks.
///
/// This unique string is printed by the runner's `delimiter_command` between
/// each code snippet. This allows the engine to split the combined stdout of a
/// batch execution back into individual results for each code block.
pub const DELIMITER: &str = "__INSCRIBE_DELIMITER_FINAL__";

/// Defines the configuration for a language runner.
///
/// It holds the necessary commands to execute a script and to print a delimiter
/// for separating outputs in batch processing.
/// It must derive Hash and Eq to be used as a key in the execution batch map.
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct Runner {
    /// The base command to execute (e.g., "python -u", "bash").
    /// This string will be split by whitespace to separate the command from its arguments.
    pub command: String,
    /// The exact, language-specific code snippet to print the stream delimiter.
    /// This is crucial for batching multiple code blocks into a single execution.
    pub delimiter_command: String,
}

/// Provides a map of language names to their default runner configurations.
///
/// This function is the source of truth for built-in language support.
/// It includes configurations for common scripting languages like Python, Bash,
/// and Node.js.
pub fn default_runners() -> HashMap<String, Runner> {
    let mut runners = HashMap::new();

    // Python: `-u` flag is used for unbuffered binary stdout and stderr.
    runners.insert(
        "python".to_string(),
        Runner {
            command: "python -u".to_string(),
            delimiter_command: format!("import sys;print('{}');sys.stdout.flush()", DELIMITER),
        },
    );

    // Bash: A standard shell, straightforward execution.
    runners.insert(
        "bash".to_string(),
        Runner {
            command: "bash".to_string(),
            delimiter_command: format!("echo '{}'", DELIMITER),
        },
    );

    // JavaScript/Node: Both "javascript" and "node" map to the Node.js runtime.
    runners.insert(
        "javascript".to_string(),
        Runner {
            command: "node".to_string(),
            delimiter_command: format!("console.log('{}')", DELIMITER),
        },
    );
    runners.insert(
        "node".to_string(),
        Runner {
            command: "node".to_string(),
            delimiter_command: format!("console.log('{}')", DELIMITER),
        },
    );

    // Ruby: Standard execution.
    runners.insert(
        "ruby".to_string(),
        Runner {
            command: "ruby".to_string(),
            delimiter_command: format!("puts '{}'", DELIMITER),
        },
    );

    // Use conditional compilation for platform-specific shell commands.
    #[cfg(unix)]
    runners.insert(
        "sh".to_string(),
        Runner {
            command: "sh".to_string(),
            delimiter_command: format!("echo '{}'", DELIMITER),
        },
    );

    #[cfg(windows)]
    runners.insert(
        "sh".to_string(),
        Runner {
            command: "cmd /C".to_string(),
            delimiter_command: format!("echo {}", DELIMITER),
        },
    );

    runners
}