flesh/src/bin/relish.rs

/* relish: versatile lisp shell
 * Copyright (C) 2021 Aidan Hahn
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

use relish::ast::{eval, lex, Ctr, Seg, SymTable, run, load_defaults, load_environment};
use relish::stdlib::{dynamic_stdlib, static_stdlib};
use relish::aux::ShellState;

use std::cell::RefCell;
use std::rc::Rc;
use std::borrow::Cow;
use std::env;

use nix::unistd;
use nu_ansi_term::{Color, Style};
use dirs::home_dir;
use reedline::{
    FileBackedHistory, DefaultHinter, DefaultValidator, Reedline, Signal,
    Prompt, PromptEditMode, PromptHistorySearch, PromptHistorySearchStatus,
};

#[derive(Clone)]
pub struct CustomPrompt(String, String, String);

impl Prompt for CustomPrompt {
    fn render_prompt_left(&self) -> Cow<str> {
        {
            Cow::Owned(self.0.to_owned())
        }
    }

    fn render_prompt_right(&self) -> Cow<str> {
        {
            Cow::Owned(self.1.to_owned())
        }
    }

    fn render_prompt_indicator(&self, _edit_mode: PromptEditMode) -> Cow<str> {
        Cow::Owned(self.2.to_owned())
    }

    fn render_prompt_multiline_indicator(&self) -> Cow<str> {
        Cow::Borrowed("++++")
    }

    fn render_prompt_history_search_indicator(
        &self,
        history_search: PromptHistorySearch,
    ) -> Cow<str> {
        let prefix = match history_search.status {
            PromptHistorySearchStatus::Passing => "",
            PromptHistorySearchStatus::Failing => "failing ",
        };

        Cow::Owned(format!(
            "({}reverse-search: {}) ",
            prefix, history_search.term
        ))
    }
}

fn main() {
    const HIST_FILE: &str = "/.relish_hist";
    const CONFIG_FILE_DEFAULT: &str = "/.relishrc";

    // default config file dirs
    let home_dir = home_dir().unwrap().to_str().unwrap().to_owned();
    let hist_file_name = home_dir.clone() + HIST_FILE;
    let cfg_file_name = home_dir + CONFIG_FILE_DEFAULT;

    let shell_state_bindings = Rc::new(RefCell::from(ShellState {
        parent_pid: unistd::Pid::from_raw(0),
        parent_pgid: unistd::Pid::from_raw(0),
        children: vec![],
        last_exit_code: 0,
    }));

    // setup symtable
    let mut syms = SymTable::new();
    load_defaults(&mut syms);
    load_environment(&mut syms);
    static_stdlib(&mut syms).unwrap_or_else(|err: String| eprintln!("{}", err));
    // reload this later with the state bindings
    dynamic_stdlib(&mut syms, None).unwrap_or_else(|err: String| eprintln!("{}", err));

    // if there are args those are scripts, run them and exit
    if env::args().count() > 1 {
        let mut iter = env::args();
        iter.next();
        for i in iter {
            run(i, &mut syms).unwrap();
        }

        return
    }

    // this is a user shell. attempt to load configuration
    {
        // scope the below borrow of syms
        let cfg_file = env::var("RELISH_CFG_FILE").unwrap_or(cfg_file_name);
        run(cfg_file.clone(), &mut syms)
            .unwrap_or_else(|err: String| eprintln!("failed to load script {}\n{}", cfg_file, err));
    }
    dynamic_stdlib(&mut syms, Some(shell_state_bindings)).unwrap_or_else(|err: String| eprintln!("{}", err));

    // setup readline
    let mut rl = Reedline::create();
    let maybe_hist: Box<FileBackedHistory>;
    if !hist_file_name.is_empty() {
        maybe_hist = Box::new(FileBackedHistory::with_file(5000, hist_file_name.into())
                              .expect("error reading history!"));
            rl = rl.with_history(maybe_hist);
    }
    rl = rl.with_hinter(Box::new(
        DefaultHinter::default()
            .with_style(Style::new().italic().fg(Color::LightGray)),
    )).with_validator(Box::new(DefaultValidator));

    // repl :)
    loop {
        let readline_prompt = make_prompt(&mut syms);
        let user_doc = rl.read_line(&readline_prompt).unwrap();
        match user_doc {
            Signal::Success(line) => {
                println!(""); // add a new line before output gets printed
                let l = line.as_str().to_owned();
                match lex(&l) {
                    Ok(a) => match eval(&a, &mut syms) {
                        Ok(a) => println!("{}", a),
                        Err(s) => println!("{}", s),
                    },
                    Err(s) => println!("{}", s),
                }
            },

            Signal::CtrlD  => {
                println!("EOF!");
                return
            },

            Signal::CtrlC => {
                println!("Interrupted!");
            },
        }
    }
}

fn make_prompt(syms: &mut SymTable) -> CustomPrompt {
    let l_ctr = *syms
        .call_symbol(&"CFG_RELISH_L_PROMPT".to_string(), &Seg::new(), true)
        .unwrap_or_else(|err: String| {
            eprintln!("{}", err);
            Box::new(Ctr::String("<prompt broken!>".to_string()))
        });
    let r_ctr = *syms
        .call_symbol(&"CFG_RELISH_R_PROMPT".to_string(), &Seg::new(), true)
        .unwrap_or_else(|err: String| {
            eprintln!("{}", err);
            Box::new(Ctr::String("<prompt broken!>".to_string()))
        });
    let d_ctr = *syms
        .call_symbol(&"CFG_RELISH_PROMPT_DELIMITER".to_string(), &Seg::new(), true)
        .unwrap_or_else(|err: String| {
            eprintln!("{}", err);
            Box::new(Ctr::String("<prompt broken!>".to_string()))
        });

    let l_str: String;
    let r_str: String;
    let d_str: String;
    if let Ctr::String(s) = l_ctr {
        l_str = s;
    } else {
        l_str = l_ctr.to_string();
    }
    if let Ctr::String(s) = r_ctr {
        r_str = s;
    } else {
        r_str = r_ctr.to_string();
    }
    if let Ctr::String(s) = d_ctr {
        d_str = s;
    } else {
        d_str = d_ctr.to_string();
    }

    CustomPrompt(l_str, r_str, d_str)
}