path: root/src/main.rs

use std::env::{self, current_dir};
use std::io::{self, Write};
use std::sync::{Arc, Mutex};
mod buffer;
mod path;
mod poem;
use poem::{read::Readable, recite::Reciteable, Poem};
mod compose;
use buffer::{getline, Key, STDIN};
use compose::Environment;
use termios::{tcsetattr, Termios, ECHO, ECHOE, ICANON, TCSANOW};

/// Starts the main shell loop
///
/// # Arguments
/// * `away` - A mutex, indicating whether or not user is at the prompt
/// * `env` - The global shell state
///
/// # Examples
/// ```
/// fn main() {
///     let mut env = compose::env();
///     let mut away = Arc::new(Mutex::new(false));
///     ...
///     repl(&mut away, &mut env);
/// }
/// ```
fn repl(
    away: &mut Arc<Mutex<bool>>,
    buffer: &mut Arc<Mutex<Vec<char>>>,
    pos: &mut Arc<Mutex<usize>>,
    comp_pos: &mut Arc<Mutex<usize>>,
    comp_len: &mut Arc<Mutex<usize>>,
    last_key: &mut Arc<Mutex<Key>>,
    env: &mut Environment,
) {
    // Setup termios flags
    let mut termios = Termios::from_fd(STDIN).unwrap();

    // Initial path refresh on startup
    env.bins = path::refresh();

    // Main shell loop
    loop {
        // Get the prompt
        let prompt = match env::var("PS1") {
            Ok(val) => val,
            Err(_) => String::from("|> "),
        };

        // Update shell title
        let home = env!("HOME");
        let mut title = match current_dir() {
            Ok(path) => String::from(path.as_os_str().to_str().unwrap_or("dwvsh")),
            Err(_) => String::from("dwvsh"),
        };

        if home.len() < title.len() && (home == &title[0..home.len()]) {
            for _ in 0..home.len() {
                title.remove(0);
            }
            title = String::from("~") + &title;
        } else if *home == title {
            title = String::from("~");
        }

        print!("\x1b]0;{}\x07", title);

        // Output the prompt
        print!("{}", prompt);
        io::stdout().flush().unwrap();

        // At the prompt
        *away.lock().unwrap() = false;

        // Unset ICANON and ECHO before the prompt
        termios.c_lflag &= !(ICANON | ECHO);
        tcsetattr(STDIN, TCSANOW, &mut termios).unwrap();

        // Wait for user input
        let bytes = getline(buffer, pos, comp_pos, comp_len, last_key);

        // Check if we've reached EOF (i.e. <C-d>)
        if bytes == 0 {
            println!();
            break;
        }

        // Convert buffer to a string and trim it
        let poetry = buffer.lock().unwrap().iter().collect::<String>();

        // Skip parsing if there is no poetry
        if poetry.is_empty() {
            continue;
        }

        // Set ICANON and ECHO for other programs after the prompt
        termios.c_lflag |= ICANON | ECHO | ECHOE;
        tcsetattr(STDIN, TCSANOW, &mut termios).unwrap();

        // Not at the prompt
        *away.lock().unwrap() = true;

        // Update shell title (max command length of 32 for now)
        if poetry.len() > 32 {
            print!("\x1b]0;{}...\x07", &poetry[0..32]);
        } else {
            print!("\x1b]0;{}\x07", &poetry);
        }
        io::stdout().flush().unwrap();

        // Parse the poem
        let poem = Poem::read(poetry.to_string(), env);
        let poem = match poem {
            Ok(poem) => poem,
            Err(e) => {
                eprintln!("dwvsh: {}", e.to_string().to_lowercase());
                continue;
            }
        };

        // Recite the poem
        match poem.recite(env) {
            Ok(_) => {}
            Err(e) => eprintln!("dwvsh: {}", e.to_string().to_lowercase()),
        }
    }
}

fn options(env: &mut Environment) {
    let args: Vec<String> = env::args().collect();
    for arg in args.iter() {
        if arg.eq("--version") {
            println!(
                "dwvsh v{} ({})",
                env!("CARGO_PKG_VERSION"),
                env!("DWVSH_BUILD")
            );
            std::process::exit(0);
        }
    }

    match args.last() {
        Some(arg) => {
            if args.len() > 1 && !arg.starts_with('-') {
                let poetry = std::fs::read_to_string(arg)
                    .expect(format!("dwvsh: can't open input file: {}", arg).as_str());
                let poem = Poem::read(poetry, env);
                let poem = match poem {
                    Ok(poem) => poem,
                    Err(e) => {
                        eprintln!("dwvsh: {}", e.to_string().to_lowercase());
                        std::process::exit(1);
                    }
                };

                // Recite the poem
                match poem.recite(env) {
                    Ok(_) => {}
                    Err(e) => eprintln!("dwvsh: {}", e.to_string().to_lowercase()),
                }

                // Quit
                std::process::exit(0);
            }
        }
        None => {}
    }
}

/// Shell entry
///
/// Shell setup and entry
fn main() {
    // Compose the environment for dwvsh
    let mut env = compose::env();

    // Set when we are not on the buffer
    let mut away = Arc::new(Mutex::new(true));

    // Any text in the current buffer
    let mut buffer: Arc<Mutex<Vec<char>>> = Arc::new(Mutex::new(Vec::new()));

    // Position in the buffer. Subject to change based on input from the user. Typing a character
    // increments the position, while backspacing will decrement it. The user may also move it
    // manually using the arrow keys to insert or delete at an arbitrary location in the buffer.
    let mut pos: Arc<Mutex<usize>> = Arc::new(Mutex::new(0));

    // Position in the autocomplete list. This value gets reset if a new autocomplete list is
    // generated (for instance, if the user preses '/' to start autocomplete in a new directory).
    let mut comp_pos: Arc<Mutex<usize>> = Arc::new(Mutex::new(0));

    // Keep track of the length of the last buffer from [crate::buffer::comp].
    let mut comp_len: Arc<Mutex<usize>> = Arc::new(Mutex::new(0));

    // Keep track of the last key for autocomplete, as we may need to add or sub additionally from
    // [comp_pos] before calling [crate::buffer::comp] (i.e. swapping directions (tab vs. shift +
    // tab)).
    let mut last_key: Arc<Mutex<Key>> = Arc::new(Mutex::new(Key::Ignored));

    // Handle signals
    unsafe {
        let away = Arc::clone(&away);
        let buffer = Arc::clone(&buffer);
        let pos = Arc::clone(&pos);
        let comp_pos = Arc::clone(&comp_pos);
        let comp_len = Arc::clone(&comp_len);
        let last_key = Arc::clone(&last_key);
        signal_hook::low_level::register(signal_hook::consts::SIGINT, move || {
            buffer.lock().unwrap().clear();
            *pos.lock().unwrap() = 0;
            *comp_pos.lock().unwrap() = 0;
            *comp_len.lock().unwrap() = 0;
            *last_key.lock().unwrap() = Key::Ignored;
            if *away.lock().unwrap() {
                println!();
            } else {
                let prompt = match env::var("PS1") {
                    Ok(val) => val,
                    Err(_) => String::from("|> "),
                };
                print!("\n{}", prompt);
                io::stdout().flush().unwrap();
            }
        })
        .unwrap();
    };

    // Parse flags and other arguments
    options(&mut env);

    // Begin evaluating commands
    repl(
        &mut away,
        &mut buffer,
        &mut pos,
        &mut comp_pos,
        &mut comp_len,
        &mut last_key,
        &mut env,
    );
}