snix_cli_eval/

repl.rs

use crate::{
    AllowIncomplete, Args, IncompleteInput, InterpretResult, assignment::Assignment, evaluate,
    interpret,
};
use rustc_hash::FxHashMap;
use rustyline::EventHandler::Conditional;
use rustyline::history::DefaultHistory;
use rustyline::{
    Cmd, ConditionalEventHandler, Editor, Event, EventContext, KeyEvent, Movement, RepeatCount,
    error::ReadlineError,
};
use smol_str::SmolStr;
use snix_eval::{GlobalsMap, SourceCode, Value};
use snix_glue::snix_store_io::SnixStoreIO;
use std::io::Write;
use std::path::PathBuf;
use std::process::Command;
use std::rc::Rc;
use std::{env, fs};
use tracing::warn;

fn state_dir() -> Option<PathBuf> {
    let mut path = dirs::data_dir();
    if let Some(p) = path.as_mut() {
        p.push("snix")
    }
    path
}

#[derive(Debug, Clone, PartialEq, Eq)]
pub(crate) 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 Snix 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)
    }
}

pub struct CommandResult {
    output: String,
    continue_: bool,
}

impl CommandResult {
    pub fn finalize<E: Write>(self, stdout: &mut E) -> bool {
        write!(stdout, "{}", self.output).unwrap();
        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<(), DefaultHistory>,
    /// Local variables defined at the top-level in the repl
    env: FxHashMap<SmolStr, Value>,

    io_handle: Rc<SnixStoreIO>,
    args: &'a Args,
    source_map: SourceCode,
    globals: Option<Rc<GlobalsMap>>,
}

struct BufferEditor;
impl ConditionalEventHandler for BufferEditor {
    fn handle(
        &self,
        _event: &Event,
        _repeat_count: RepeatCount,
        _positive: bool,
        ctx: &EventContext<'_>,
    ) -> Option<Cmd> {
        let tempdir = tempfile::tempdir()
            .inspect_err(|e| {
                warn!(err=%e, "failed to create tempdir for editing");
            })
            .ok()?;

        let editor_cmd = env::var("VISUAL")
            .or_else(|_| env::var("EDITOR"))
            .unwrap_or_else(|_| String::from("nano"));

        let path = tempdir.path().join("expression.nix");

        fs::write(&path, ctx.line())
            .inspect_err(|e| {
                warn!(err=%e, "failed to write buffer to file");
            })
            .ok()?;

        Command::new(&editor_cmd)
            .arg(&path)
            .status()
            .inspect_err(|e| {
                warn!(err=%e, "editor returned with error");
            })
            .ok()?;

        let new_content = fs::read_to_string(&path)
            .inspect_err(|e| {
                warn!(err=%e, "failed to read back in edited buffer");
            })
            .ok()?;

        Some(Cmd::Replace(Movement::WholeBuffer, Some(new_content)))
    }
}

impl<'a> Repl<'a> {
    pub fn new(io_handle: Rc<SnixStoreIO>, args: &'a Args) -> Self {
        let mut rl =
            Editor::<(), DefaultHistory>::new().expect("should be able to launch rustyline");

        // Registering keybind(s)
        Self::binds(&mut rl);

        Self {
            multiline_input: None,
            rl,
            env: FxHashMap::default(),
            io_handle,
            args,
            source_map: Default::default(),
            globals: None,
        }
    }

    fn binds(rl: &mut Editor<(), DefaultHistory>) {
        rl.bind_sequence(KeyEvent::ctrl('o'), Conditional(Box::new(BufferEditor)));
    }

    pub fn run<O: Write + Clone + Send, E: Write + Clone + Send>(
        &mut self,
        stdout: &mut O,
        stderr: &mut E,
    ) {
        if self.args.compile_only {
            writeln!(
                stderr,
                "warning: `--compile-only` has no effect on REPL usage!"
            )
            .unwrap();
        }

        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 {
                "snix-repl> "
            };

            let readline = self.rl.readline(prompt);
            match readline {
                Ok(line) => {
                    if !self.send(stderr, line).finalize(stdout) {
                        break;
                    }
                }
                Err(ReadlineError::Interrupted) | Err(ReadlineError::Eof) => break,

                Err(err) => {
                    writeln!(stderr, "error: {err}").unwrap();
                    break;
                }
            }
        }

        if let Some(path) = history_path {
            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<E: Write + Clone + Send>(&mut self, stderr: &mut E, 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_: false,
                };
            }
            ReplCommand::Help => {
                println!("{}", ReplCommand::HELP);
                Ok(InterpretResult::empty_success(None))
            }
            ReplCommand::Expr(input) => interpret(
                stderr,
                Rc::clone(&self.io_handle),
                input,
                None,
                self.args,
                false,
                AllowIncomplete::Allow,
                Some(&self.env),
                self.globals.clone(),
                Some(self.source_map.clone()),
            ),
            ReplCommand::Assign(Assignment { ident, value }) => {
                match evaluate(
                    stderr,
                    Rc::clone(&self.io_handle),
                    &value.to_string(), /* FIXME: don't re-parse */
                    None,
                    self.args,
                    AllowIncomplete::Allow,
                    Some(&self.env),
                    self.globals.clone(),
                    Some(self.source_map.clone()),
                ) {
                    Ok(result) => {
                        if let Some(value) = result.value {
                            self.env.insert(ident.into(), value);
                        }
                        Ok(InterpretResult::empty_success(Some(result.globals)))
                    }
                    Err(incomplete) => Err(incomplete),
                }
            }
            ReplCommand::Explain(input) => interpret(
                stderr,
                Rc::clone(&self.io_handle),
                input,
                None,
                self.args,
                true,
                AllowIncomplete::Allow,
                Some(&self.env),
                self.globals.clone(),
                Some(self.source_map.clone()),
            ),
            ReplCommand::Print(input) => interpret(
                stderr,
                Rc::clone(&self.io_handle),
                input,
                None,
                &Args {
                    strict: true,
                    ..(self.args.clone())
                },
                false,
                AllowIncomplete::Allow,
                Some(&self.env),
                self.globals.clone(),
                Some(self.source_map.clone()),
            ),
        };

        match res {
            Ok(InterpretResult {
                output,
                globals,
                success: _,
            }) => {
                let _ = self.rl.add_history_entry(input);
                self.multiline_input = None;
                if globals.is_some() {
                    self.globals = globals;
                }
                CommandResult {
                    output,
                    continue_: true,
                }
            }
            Err(IncompleteInput) => {
                if self.multiline_input.is_none() {
                    self.multiline_input = Some(line);
                }
                CommandResult {
                    output: String::new(),
                    continue_: true,
                }
            }
        }
    }
}