maurice/snix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

test(tvix/cli): Make the REPL testable

Browse source 
Juggle around the internals of the tvix-cli crate so that we expose the
Repl as a public type with a `send` method, that sends a string to the
repl and *captures all output* so that it can be subsequently asserted
on in tests. Then, demonstrate that this works with a single (for now)
REPL test using expect-test to assert on the output of a single command
sent to the REPL.

As the REPL gets more complicated, this will allow us to make tests that
cover that complex behavior.

Change-Id: I88175bd72d8760c79faade95ebb1d956f08a7b83
Reviewed-on: https://cl.tvl.fyi/c/depot/+/11958
Autosubmit: aspen <root@gws.fyi>
Tested-by: BuildkiteCI
Reviewed-by: flokli <flokli@flokli.de>
This commit is contained in:
Aspen Smith 2024-07-06 09:00:46 -04:00 • committed by clbot
parent 3a79f93795
commit 0ad986169d
9 changed files with 522 additions and 346 deletions
Download patch file Download diff file Expand all files Collapse all files

218
tvix/cli/src/repl.rs
View file

@ -6,8 +6,10 @@ use smol_str::SmolStr;
use tvix_eval::Value;
use tvix_glue::tvix_store_io::TvixStoreIO;
use crate::evaluate;
use crate::{assignment::Assignment, interpret, AllowIncomplete, Args, IncompleteInput};
use crate::{
assignment::Assignment, evaluate, interpret, AllowIncomplete, Args, IncompleteInput,
InterpretResult,
};
fn state_dir() -> Option<PathBuf> {
let mut path = dirs::data_dir();
@ -18,7 +20,7 @@ fn state_dir() -> Option<PathBuf> {
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ReplCommand<'a> {
pub(crate) enum ReplCommand<'a> {
Expr(&'a str),
Assign(Assignment<'a>),
Explain(&'a str),
@ -65,27 +67,47 @@ The following commands are supported:
}
}
#[derive(Debug)]
pub struct Repl {
pub struct CommandResult {
output: String,
continue_: bool,
}
impl CommandResult {
pub fn finalize(self) -> bool {
print!("{}", self.output);
self.continue_
}
pub fn output(&self) -> &str {
&self.output
}
}
pub struct Repl<'a> {
/// In-progress multiline input, when the input so far doesn't parse as a complete expression
multiline_input: Option<String>,
rl: Editor<()>,
/// Local variables defined at the top-level in the repl
env: HashMap<SmolStr, Value>,
io_handle: Rc<TvixStoreIO>,
args: &'a Args,
}
impl Repl {
pub fn new() -> Self {
impl<'a> Repl<'a> {
pub fn new(io_handle: Rc<TvixStoreIO>, args: &'a Args) -> Self {
let rl = Editor::<()>::new().expect("should be able to launch rustyline");
Self {
multiline_input: None,
rl,
env: HashMap::new(),
io_handle,
args,
}
}
pub fn run(&mut self, io_handle: Rc<TvixStoreIO>, args: &Args) {
if args.compile_only {
pub fn run(&mut self) {
if self.args.compile_only {
eprintln!("warning: `--compile-only` has no effect on REPL usage!");
}
@ -112,83 +134,8 @@ impl Repl {
let readline = self.rl.readline(prompt);
match readline {
Ok(line) => {
if line.is_empty() {
continue;
}
let input = if let Some(mi) = &mut self.multiline_input {
mi.push('\n');
mi.push_str(&line);
mi
} else {
&line
};
let res = match ReplCommand::parse(input) {
ReplCommand::Quit => break,
ReplCommand::Help => {
println!("{}", ReplCommand::HELP);
Ok(false)
}
ReplCommand::Expr(input) => interpret(
Rc::clone(&io_handle),
input,
None,
args,
false,
AllowIncomplete::Allow,
Some(&self.env),
),
ReplCommand::Assign(Assignment { ident, value }) => {
match evaluate(
Rc::clone(&io_handle),
&value.to_string(), /* FIXME: don't re-parse */
None,
args,
AllowIncomplete::Allow,
Some(&self.env),
) {
Ok(Some(value)) => {
self.env.insert(ident.into(), value);
Ok(true)
}
Ok(None) => Ok(true),
Err(incomplete) => Err(incomplete),
}
}
ReplCommand::Explain(input) => interpret(
Rc::clone(&io_handle),
input,
None,
args,
true,
AllowIncomplete::Allow,
Some(&self.env),
),
ReplCommand::Print(input) => interpret(
Rc::clone(&io_handle),
input,
None,
&Args {
strict: true,
..(args.clone())
},
false,
AllowIncomplete::Allow,
Some(&self.env),
),
};
match res {
Ok(_) => {
self.rl.add_history_entry(input);
self.multiline_input = None;
}
Err(IncompleteInput) => {
if self.multiline_input.is_none() {
self.multiline_input = Some(line);
}
}
if !self.send(line).finalize() {
break;
}
}
Err(ReadlineError::Interrupted) | Err(ReadlineError::Eof) => break,
@ -204,4 +151,103 @@ impl Repl {
self.rl.save_history(&path).unwrap();
}
}
/// Send a line of user input to the REPL. Returns a result indicating the output to show to the
/// user, and whether or not to continue
pub fn send(&mut self, line: String) -> CommandResult {
if line.is_empty() {
return CommandResult {
output: String::new(),
continue_: true,
};
}
let input = if let Some(mi) = &mut self.multiline_input {
mi.push('\n');
mi.push_str(&line);
mi
} else {
&line
};
let res = match ReplCommand::parse(input) {
ReplCommand::Quit => {
return CommandResult {
output: String::new(),
continue_: true,
};
}
ReplCommand::Help => {
println!("{}", ReplCommand::HELP);
Ok(InterpretResult::empty_success())
}
ReplCommand::Expr(input) => interpret(
Rc::clone(&self.io_handle),
input,
None,
self.args,
false,
AllowIncomplete::Allow,
Some(&self.env),
),
ReplCommand::Assign(Assignment { ident, value }) => {
match evaluate(
Rc::clone(&self.io_handle),
&value.to_string(), /* FIXME: don't re-parse */
None,
self.args,
AllowIncomplete::Allow,
Some(&self.env),
) {
Ok(Some(value)) => {
self.env.insert(ident.into(), value);
Ok(InterpretResult::empty_success())
}
Ok(None) => Ok(InterpretResult::empty_success()),
Err(incomplete) => Err(incomplete),
}
}
ReplCommand::Explain(input) => interpret(
Rc::clone(&self.io_handle),
input,
None,
self.args,
true,
AllowIncomplete::Allow,
Some(&self.env),
),
ReplCommand::Print(input) => interpret(
Rc::clone(&self.io_handle),
input,
None,
&Args {
strict: true,
..(self.args.clone())
},
false,
AllowIncomplete::Allow,
Some(&self.env),
),
};
match res {
Ok(InterpretResult { output, .. }) => {
self.rl.add_history_entry(input);
self.multiline_input = None;
CommandResult {
output,
continue_: true,
}
}
Err(IncompleteInput) => {
if self.multiline_input.is_none() {
self.multiline_input = Some(line);
}
CommandResult {
output: String::new(),
continue_: true,
}
}
}
}
}