use std::rc::Rc;
use std::{collections::HashMap, path::PathBuf};
use rustyline::{error::ReadlineError, Editor};
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};
fn state_dir() -> Option<PathBuf> {
let mut path = dirs::data_dir();
if let Some(p) = path.as_mut() {
p.push("tvix")
}
path
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum ReplCommand<'a> {
Expr(&'a str),
Assign(Assignment<'a>),
Explain(&'a str),
Print(&'a str),
Quit,
Help,
}
impl<'a> ReplCommand<'a> {
const HELP: &'static str = "
Welcome to the Tvix REPL!
The following commands are supported:
<expr> Evaluate a Nix language expression and print the result, along with its inferred type
<x> = <expr> Bind the result of an expression to a variable
:d <expr> Evaluate a Nix language expression and print a detailed description of the result
:p <expr> Evaluate a Nix language expression and print the result recursively
:q Exit the REPL
:?, :h Display this help text
";
pub fn parse(input: &'a str) -> Self {
if input.starts_with(':') {
if let Some(without_prefix) = input.strip_prefix(":d ") {
return Self::Explain(without_prefix);
} else if let Some(without_prefix) = input.strip_prefix(":p ") {
return Self::Print(without_prefix);
}
let input = input.trim_end();
match input {
":q" => return Self::Quit,
":h" | ":?" => return Self::Help,
_ => {}
}
}
if let Some(assignment) = Assignment::parse(input) {
return Self::Assign(assignment);
}
Self::Expr(input)
}
}
#[derive(Debug)]
pub struct Repl {
/// 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>,
}
impl Repl {
pub fn new() -> Self {
let rl = Editor::<()>::new().expect("should be able to launch rustyline");
Self {
multiline_input: None,
rl,
env: HashMap::new(),
}
}
pub fn run(&mut self, io_handle: Rc<TvixStoreIO>, args: &Args) {
if args.compile_only {
eprintln!("warning: `--compile-only` has no effect on REPL usage!");
}
let history_path = match state_dir() {
// Attempt to set up these paths, but do not hard fail if it
// doesn't work.
Some(mut path) => {
let _ = std::fs::create_dir_all(&path);
path.push("history.txt");
let _ = self.rl.load_history(&path);
Some(path)
}
None => None,
};
loop {
let prompt = if self.multiline_input.is_some() {
" > "
} else {
"tvix-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);
}
}
}
}
Err(ReadlineError::Interrupted) | Err(ReadlineError::Eof) => break,
Err(err) => {
eprintln!("error: {}", err);
break;
}
}
}
if let Some(path) = history_path {
self.rl.save_history(&path).unwrap();
}
}
}