isksh 0.1.2

A portable POSIX-oriented shell written in Rust
Documentation
use crate::{RunResult, Shell};
use std::ffi::OsString;
use std::fs;
use std::io;
use std::path::{Path, PathBuf};

pub fn startup_file() -> Option<PathBuf> {
    let home = std::env::var_os("HOME").or(std::env::var_os("USERPROFILE"));
    startup_file_from(
        std::env::var_os("ISKSH_RC"),
        std::env::var_os("XDG_CONFIG_HOME"),
        home,
    )
}

pub fn bash_startup_file() -> Option<PathBuf> {
    bash_startup_file_from(
        std::env::var_os("ISKSH_RC").is_some(),
        std::env::var_os("HOME").or(std::env::var_os("USERPROFILE")),
    )
}

fn bash_startup_file_from(override_present: bool, home: Option<OsString>) -> Option<PathBuf> {
    if override_present {
        return None;
    }
    home.filter(|path| !path.is_empty())
        .map(PathBuf::from)
        .map(|path| path.join(".bashrc"))
}

fn startup_file_from(
    override_path: Option<OsString>,
    config_home: Option<OsString>,
    home: Option<OsString>,
) -> Option<PathBuf> {
    if let Some(path) = override_path {
        return (!path.is_empty()).then(|| PathBuf::from(path));
    }
    if let Some(path) = config_home.filter(|path| !path.is_empty()) {
        return Some(PathBuf::from(path).join("isksh").join(".iskrc"));
    }
    home.filter(|path| !path.is_empty())
        .map(PathBuf::from)
        .map(|path| path.join(".config").join("isksh").join(".iskrc"))
}

pub fn load_startup_file(shell: &mut Shell, path: &Path) -> io::Result<Option<RunResult>> {
    let bytes = match fs::read(path) {
        Ok(bytes) => bytes,
        Err(error) if error.kind() == io::ErrorKind::NotFound => return Ok(None),
        Err(error) => return Err(error),
    };
    let source = String::from_utf8(bytes).map_err(|error| {
        io::Error::new(
            io::ErrorKind::InvalidData,
            format!(
                "{}: input must be valid UTF-8 (invalid byte at offset {})",
                path.display(),
                error.utf8_error().valid_up_to()
            ),
        )
    })?;
    Ok(Some(shell.run(&source, &[])))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn resolves_override_xdg_home_and_disabled_paths() {
        let _ = startup_file();
        let _ = bash_startup_file();
        assert_eq!(
            startup_file_from(Some("custom.rc".into()), None, None),
            Some(PathBuf::from("custom.rc"))
        );
        assert_eq!(
            startup_file_from(None, Some("config".into()), None),
            Some(PathBuf::from("config/isksh/.iskrc"))
        );
        assert_eq!(
            startup_file_from(None, None, Some("home".into())),
            Some(PathBuf::from("home/.config/isksh/.iskrc"))
        );
        assert_eq!(startup_file_from(Some(OsString::new()), None, None), None);
        assert_eq!(startup_file_from(None, None, None), None);
        assert_eq!(bash_startup_file_from(true, Some("home".into())), None);
        assert_eq!(
            bash_startup_file_from(false, Some("home".into())),
            Some(PathBuf::from("home/.bashrc"))
        );
        assert_eq!(bash_startup_file_from(false, Some(OsString::new())), None);
        assert_eq!(bash_startup_file_from(false, None), None);
    }

    #[test]
    fn loads_supported_bashrc_style_syntax_and_handles_errors() {
        let directory = tempfile::tempdir().unwrap();
        let path = directory.path().join(".iskrc");
        fs::write(
            &path,
            concat!(
                "# bashrc-style configuration\n",
                "export ISKSH_TEST=configured\n",
                "alias greet='printf configured'\n",
                "prompt_name() { printf '%s' \"$ISKSH_TEST\"; }\n",
            ),
        )
        .unwrap();
        let mut shell = Shell::default();
        assert_eq!(
            load_startup_file(&mut shell, &path)
                .unwrap()
                .unwrap()
                .status,
            0
        );
        assert_eq!(
            shell.run("greet; prompt_name", &[]).stdout,
            b"configuredconfigured"
        );
        assert!(
            load_startup_file(&mut shell, &directory.path().join("missing"))
                .unwrap()
                .is_none()
        );

        fs::write(&path, [0xff]).unwrap();
        assert_eq!(
            load_startup_file(&mut shell, &path).unwrap_err().kind(),
            io::ErrorKind::InvalidData
        );
        assert!(load_startup_file(&mut shell, directory.path()).is_err());
    }
}