newts 0.3.0

A cross-language notebook terminal interface and server.
Documentation 
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
103
104
105
106
107
108
109
110
111
112
113
114
115

use newts::server::kernel::{PythonKernel, NodeKernel, CppKernel, RustKernel, GoKernel, Kernel};
use std::thread;
use std::time::Duration;
use std::fs;
use std::env;

fn simulate_input(input_str: &str) {
    let temp_dir = env::temp_dir();
    let req_path = temp_dir.join("newt_web_input_req");
    let res_path = temp_dir.join("newt_web_input_res");

    // Wait for request
    let start = std::time::Instant::now();
    println!("Test: Waiting for request at {:?}", req_path);
    while !req_path.exists() {
        if start.elapsed().as_secs() > 30 {
            panic!("Timeout waiting for input request at {:?}", req_path);
        }
        thread::sleep(Duration::from_millis(100));
    }
    println!("Test: Found request");

    // Write response
    fs::write(&res_path, input_str).expect("Failed to write response");
    println!("Test: Wrote response to {:?}", res_path);
}

#[test]
fn test_python_input() {
    unsafe { std::env::set_var("NEWT_TEST_MODE", "1"); }
    let mut kernel = PythonKernel::new(None).expect("Failed to init kernel");
    
    let code = "x = input('Enter: '); print(f'Got: {x}')".to_string();
    
    let handle = thread::spawn(move || {
        kernel.execute(code, None, None, None).expect("Exec failed")
    });

    simulate_input("Hello Python");

    let resp = handle.join().expect("Thread panicked");
    assert_eq!(resp.status, Some(0));
    assert!(resp.stdout.contains("Got: Hello Python"));
}

#[test]
fn test_node_input() {
    let mut kernel = NodeKernel::new().expect("Failed to init kernel");
    
    let code = "const x = input('Enter: '); console.log(`Got: ${x}`);".to_string();
    
    let handle = thread::spawn(move || {
        kernel.execute(code, None, None, None).expect("Exec failed")
    });

    simulate_input("Hello Node");

    let resp = handle.join().expect("Thread panicked");
    assert_eq!(resp.status, Some(0));
    assert!(resp.stdout.contains("Got: Hello Node"));
}

#[test]
fn test_cpp_input() {
    let mut kernel = CppKernel::new();
    
    let code = "std::string x; std::cin >> x; std::cout << \"Got: \" << x;".to_string();
    
    let handle = thread::spawn(move || {
        kernel.execute(code, None, None, None).expect("Exec failed")
    });

    simulate_input("HelloCpp");

    let resp = handle.join().expect("Thread panicked");
    assert_eq!(resp.status, Some(0));
    assert!(resp.stdout.contains("Got: HelloCpp"));
}

#[test]
fn test_rust_input() {
    let mut kernel = RustKernel::new();
    
    // Use standard std::io::stdin
    let code = "use std::io; let mut x = String::new(); io::stdin().read_line(&mut x).unwrap(); println!(\"Got: {}\", x.trim());".to_string();
    
    let handle = thread::spawn(move || {
        kernel.execute(code, None, None, None).expect("Exec failed")
    });

    simulate_input("HelloRust");

    let resp = handle.join().expect("Thread panicked");
    assert_eq!(resp.status, Some(0));
    assert!(resp.stdout.contains("Got: HelloRust"));
}

#[test]
fn test_go_input() {
    let mut kernel = GoKernel::new();
    
    // Use standard fmt.Scan with short declaration to avoid top-level var issue
    let code = "x := \"\"; fmt.Scan(&x); fmt.Printf(\"Got: %s\", x)".to_string();
    
    let handle = thread::spawn(move || {
        kernel.execute(code, None, None, None).expect("Exec failed")
    });

    simulate_input("HelloGo");

    let resp = handle.join().expect("Thread panicked");
    assert_eq!(resp.status, Some(0));
    assert!(resp.stdout.contains("Got: HelloGo"));
}