oysh/crates/oyster_runtime/src/builtins/mod.rs

use std::{borrow::Cow, collections::HashMap, ffi::OsStr};

use oyster_builtin_proc::builtin;

use crate::Shell;

#[derive(Clone, Copy)]
pub struct Builtin {
    pub name: &'static str,
    pub description: &'static str,
    pub nofork: bool,
    pub fun: fn(shell: &mut Shell, args: &[Cow<OsStr>]),
}

#[builtin(description = "prints help for different builtins")]
pub fn help(shell: &mut Shell, _args: &[Cow<OsStr>]) {
    println!(
        r"oyster help:

These are the loaded builtins:"
    );

    for builtin in shell.builtins().iter() {
        println!("  {: <8} {}", builtin.name, builtin.description);
    }
}

/// Used to register and retrieve builtins.
/// Builtin names gotta be valid unicode.
#[derive(Default)]
pub struct BuiltinMap(HashMap<&'static str, Builtin>);

impl BuiltinMap {
    /// Register a new builtin.
    pub fn add(&mut self, builtin: Builtin) {
        self.0.insert(builtin.name, builtin);
    }

    /// Get a builtin with a given name, if it exists.
    pub fn get(&self, name: &str) -> Option<&Builtin> {
        self.0.get(name)
    }

    /// Returns an iterator over all currently registered builtins.
    pub fn iter(&self) -> impl Iterator<Item = &Builtin> {
        self.0.iter().map(|(_, v)| v)
    }

    /// Add default builtins.
    pub fn add_defaults(&mut self) {
        self.add(help);
    }
}

impl Shell {
    /// Retrieve builtins.
    pub fn builtins(&self) -> &BuiltinMap {
        &self.builtins
    }

    /// Retrieve builtins, mutably.
    pub fn builtins_mut(&mut self) -> &mut BuiltinMap {
        &mut self.builtins
    }
}