Merge pull request #312 from michaelb/dev

Dev

Author: michaelb

.github/workflows/rust.yml

@@ -37,7 +37,7 @@ jobs:
         persist-credentials: false
     - uses: dtolnay/rust-toolchain@stable
     - name: Build
-      run: cargo build --verbose --release --target x86_64-unknown-linux-gnu 
+      run: cargo build --verbose --release --locked --target x86_64-unknown-linux-gnu 
 
   buildmsrv:
     name: build-msrv
@@ -59,7 +59,7 @@ jobs:
           persist-credentials: false
       - uses: dtolnay/rust-toolchain@nightly
       - name: build
-        run: cargo build --release --target x86_64-unknown-linux-gnu 
+        run: cargo build --release --locked --target x86_64-unknown-linux-gnu 
 
   unittest:
     name: unit & integration tests

CHANGELOG.md

@@ -1,3 +1,9 @@
+## v1.3.18
+- Swift support (incl. REPL)
+- Configurable REPL timeout
+- Rust_original now repl capable (based on evcxr)
+- REPL limitation 'please re-run your snippet' removed
+
 ## v1.3.17
 - better fallback messages
 - Terminal display mode fixes (courtesy of @dbeecham)

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "sniprun"
-version = "1.3.17"
+version = "1.3.18"
 authors = ["michaelb <michael.bleuez2@gmail.com>"]
 rust-version = "1.65"
 edition = "2018"

Cargo.toml

@@ -41,8 +41,8 @@ require('sniprun').setup({
             some_specific_option = value,
             some_other_option = other_value,
         }
-    }
-  }, 
+    },
+    -- ...
 })
 EOF
 ```
@@ -65,7 +65,7 @@ require('sniprun').setup({
                                             --# the hint is available for every interpreter
                                             --# but may not be always respected
         }
-  }, 
+    }, 
 })
 EOF
 ```
@@ -83,11 +83,35 @@ interpreter_options = {
 }
 ```
 
+### The "repl_timeout" key
+
+REPL-enabled interpreters _sometime_ have mechanisms in place to limit how long a snippet of code
+can run. Be it because an infinite loop was (unintentionally?) run, or "something happened" which
+can make the interpreter unsuable in the meantime, limiting that 'meantime' is generally a good idea.
+
+By default, this timeout is set to 30s, after which, if no result was produced, the message:
+`Interpreter limitation: reached the repl timeout` is returned (as an error).
+
+Note that running an infinite loop may still cause the underlying REPL of the language (in the
+cases where one is used) to be stuck. The only purpose of this timeout is actually to warn the user
+something is taking 'probably' too long. This is why after getting such an error, it's better to
+run a `SnipReset` before trying to continue using the interpreter.
+
+This key is customizable per-interpreter, though only some (most) REPL-enabled interpreter will respect it:
+
+```lua
+interpreter_options = {
+  Python3_fifo = {
+    repl_timeout = 900, -- 900s = 15min max runtime
+  },
+```
+
+
 ### The "error_truncate" key
 
 Also available for every interpreter if you don't like how sniprun truncate some outputs by default (auto), but it will not have an effect on all interpreters.
 
-```
+```lua
 interpreter_options = {
     Python3_original = {
         error_truncate = "auto"     --# Truncate runtime errors 'long', 'short' or 'auto'
@@ -120,6 +144,7 @@ sniprun internally expect, or be straight out incompatible with the formers. Be
 
 Exceptions:
  - Scala_original has both interpreter and compiler keys that should be set consistently with each other
- - *_jupyter, Generic, GFM_original, Orgmode_original, and Neorg_original do not support any of these keys, as they rely on the interpreter for the code's block language.
+ - *_jupyter, Generic, GFM_original, Orgmode_original, and Neorg_original do not support any of these keys,
+   as they rely on the underlying interpreter for the code's block language and use its configuration.
 
 

doc/sources/common_options.md

@@ -1,5 +1,23 @@
 ## TypeScript original
 
-Requires `ts-node`, usually installed from npm
+Prior to NodeJS v22.6.0:
+Install `ts-node`, usually installed from npm
 
 `sudo npm install -g ts-node typescript`
+
+---
+
+If you have NodeJS v22.6.0+:
+
+```lua
+require'sniprun'.setup({
+    interpreter_options = {
+        TypeScript_original = {
+            interpreter = 'node'
+            }
+        }
+    }
+})
+```
+
+[^1]: `ts-node` and `typescript` packages are no longer needed for newer NodeJS versions

doc/sources/interpreters/TypeScript_original.md

@@ -26,7 +26,6 @@ Just like you implemented the Interpreter trait for a conventional runner, you'l
 
 1. Running something in the background:
 
-    Unfortunately, this require a first workaround. It's mainly due to how sniprun can't really launch a background process that stays alive, even when the thread executing the user's command exits, and sorta re-launch itself some time later (the interpreters needs some time to launch) to execute the input. The first user command will always fail with a message ("launching .. interpreter in the background, please re-run last snippet").
     ```rust
       fn fetch_code_repl(&mut self) -> Result<(), SniprunError> {
         if !self.read_previous_code().is_empty() {
@@ -57,11 +56,11 @@ Just like you implemented the Interpreter trait for a conventional runner, you'l
 
             let pause = std::time::Duration::from_millis(100);
             std::thread::sleep(pause);
-            self.save_code("kernel_launched\nimport sys".to_owned());
 
-            Err(SniprunError::CustomError(
-                "Python3 kernel launched, re-run your snippet".to_owned(),
-            ))
+            self.save_code("kernel_launched\n".to_owned());
+            let v = vec![(self.data.range[0] as usize, self.data.range[1] as usize)];
+            Err(SniprunError::ReRunRanges(v)) // special error that tells sniprun to re-run a snippet
+                                              // which is simpler than to embed calls to fetch/build/.. here
         }
     ```
     The important thing to note is that `self.read_previous_code()` is used to determine whether a kernel was already launched; (`self.get_pid()/set_pid()` can be used to store an incrementing number of 'runs' or the child's PID, or whatever.

ressources/CONTRIBUTING_REPL.md

@@ -1,6 +1,4 @@
-/**
-Derived from https://github.com/immortal/fork
-*/
+//! Derived from https://github.com/immortal/fork
 
 /// Fork result
 pub enum Fork {

ressources/demo_display.py

@@ -439,7 +439,7 @@ pub fn display_floating_window(
         .current_bloc
         .lines()
         .filter(|&line| !line.is_empty())
-        .last()
+        .next_back()
         .unwrap_or(&data.current_line)
         .len();
     let row = data.range[0] + data.current_bloc.trim_end_matches('\n').lines().count() as i64 - 1;
@@ -533,7 +533,7 @@ fn shorten_ok(message: &str) -> String {
         + message
             .lines()
             .filter(|&s| !s.is_empty())
-            .last()
+            .next_back()
             .unwrap_or("")
 }
 

src/daemonizer.rs

@@ -199,6 +199,7 @@ pub trait InterpreterUtils {
     fn contains_main(entry: &str, snippet: &str, comment: &str) -> bool;
     fn error_truncate(data: &DataHolder) -> ErrTruncate;
 
+    fn get_repl_timeout(data: &DataHolder) -> u64;
     fn get_compiler_or(data: &DataHolder, or: &str) -> String;
     fn get_interpreter_or(data: &DataHolder, or: &str) -> String;
 }
@@ -303,6 +304,16 @@ impl<T: Interpreter> InterpreterUtils for T {
         None
     }
 
+    /// returns the configured time (in seconds) to wait for a repl response
+    /// Default: 30s
+    fn get_repl_timeout(data: &DataHolder) -> u64 {
+        if let Some(timeout) = T::get_interpreter_option(data, "repl_timeout") {
+            timeout.as_u64().unwrap_or(30)
+        } else {
+            30
+        }
+    }
+
     fn get_compiler_or(data: &DataHolder, or: &str) -> String {
         if let Some(compiler) = T::get_interpreter_option(data, "compiler") {
             if let Some(compiler_valid_str) = compiler.as_str() {

src/display.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::zombie_processes)]
 use crate::interpreters::import::*;
 
 #[derive(Clone)]
@@ -42,9 +43,9 @@ impl Clojure_fifo {
             pause = pause.saturating_add(std::time::Duration::from_millis(50));
 
             // timeout after 30s if no result found
-            if start.elapsed().as_secs() > 30 {
+            if start.elapsed().as_secs() > Clojure_fifo::get_repl_timeout(&self.data) {
                 return Err(SniprunError::InterpreterLimitationError(String::from(
-                    "reached the 30s timeout",
+                    "reached the repl timeout",
                 )));
             }
 
@@ -294,13 +295,10 @@ impl ReplLikeInterpreter for Clojure_fifo {
             };
 
             self.save_code("kernel_launched\n".to_owned());
-
-            let pause = std::time::Duration::from_millis(300);
+            let pause = std::time::Duration::from_millis(100);
             std::thread::sleep(pause);
-
-            Err(SniprunError::CustomError(
-                "Clojure interactive kernel launched, re-run your snippet".to_owned(),
-            ))
+            let v = vec![(self.data.range[0] as usize, self.data.range[1] as usize)];
+            Err(SniprunError::ReRunRanges(v))
         }
     }
 

src/interpreter.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::zombie_processes)]
 use crate::interpreters::import::*;
 
 #[derive(Clone)]
@@ -240,13 +241,11 @@ impl ReplLikeInterpreter for Elixir_original {
                 ),
             };
 
+            self.save_code("kernel_launched\n".to_owned());
             let pause = std::time::Duration::from_millis(100);
             std::thread::sleep(pause);
-            self.save_code("kernel_launched".to_owned());
-
-            Err(SniprunError::CustomError(
-                "elixir kernel launched, re-run your snippet".to_owned(),
-            ))
+            let v = vec![(self.data.range[0] as usize, self.data.range[1] as usize)];
+            Err(SniprunError::ReRunRanges(v))
         }
     }
 

src/interpreters/Clojure_fifo.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::zombie_processes)]
 use crate::interpreters::import::*;
 
 #[derive(Clone)]
@@ -38,9 +39,9 @@ impl FSharp_fifo {
             pause = pause.saturating_add(std::time::Duration::from_millis(50));
 
             // timeout after 30s if no result found
-            if start.elapsed().as_secs() > 30 {
+            if start.elapsed().as_secs() > FSharp_fifo::get_repl_timeout(&self.data) {
                 return Err(SniprunError::InterpreterLimitationError(String::from(
-                    "reached the 30s timeout",
+                    "reached the repl timeout",
                 )));
             }
 
@@ -282,9 +283,12 @@ impl ReplLikeInterpreter for FSharp_fifo {
             let pause = std::time::Duration::from_millis(2000); // prevent an user from re-running the snippet
                                                                 // before dotnet launches (2-3 secs)
             std::thread::sleep(pause);
-            Err(SniprunError::CustomError(
-                "F# interactive kernel launched, re-run your snippet".to_owned(),
-            ))
+
+            self.save_code("kernel_launched\n".to_owned());
+            let pause = std::time::Duration::from_millis(100);
+            std::thread::sleep(pause);
+            let v = vec![(self.data.range[0] as usize, self.data.range[1] as usize)];
+            Err(SniprunError::ReRunRanges(v))
         }
     }
 

src/interpreters/Elixir_original.rs

@@ -124,7 +124,11 @@ impl Go_original {
     }
 
     fn parse_import_path(p: &str) -> String {
-        p.replace('\"', "").split('/').last().unwrap().to_string()
+        p.replace('\"', "")
+            .split('/')
+            .next_back()
+            .unwrap()
+            .to_string()
     }
 }
 

src/interpreters/FSharp_fifo.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::zombie_processes)]
 use crate::interpreters::import::*;
 
 #[derive(Clone)]
@@ -31,9 +32,9 @@ impl JS_TS_bun {
             pause = pause.saturating_add(std::time::Duration::from_millis(50));
 
             // timeout after 30s if no result found
-            if start.elapsed().as_secs() > 30 {
+            if start.elapsed().as_secs() > JS_TS_bun::get_repl_timeout(&self.data) {
                 return Err(SniprunError::InterpreterLimitationError(String::from(
-                    "reached the 30s timeout",
+                    "reached the repl timeout",
                 )));
             }
 
@@ -220,7 +221,7 @@ impl Interpreter for JS_TS_bun {
                         .unwrap()
                         .lines()
                         .filter(|l| l.contains("Error:"))
-                        .last()
+                        .next_back()
                         .unwrap_or(&String::from_utf8(output.stderr).unwrap())
                         .to_string(),
                 ))