4 releases (2 stable)

2.0.0 Jun 6, 2024
1.0.0 May 18, 2024
0.2.0 May 7, 2024
0.1.0 May 7, 2024

#433 in Programming languages

Download history 23/week @ 2024-07-25 2/week @ 2024-08-01 4/week @ 2024-09-19 2/week @ 2024-09-26 1/week @ 2024-10-03

255 downloads per month

MIT license

21KB
286 lines

rusty-cmd

A crate for creating custom line-oriented command interpreters in Rust.

License: MIT Rust Documentation

I wrote this as a Rust learning project and was inspired by Python's cmd and the dev.to article: A small library for writing line oriented-command interpreters in rust.

Features

  • Create and register custom command interpreters using the CommandHandler trait, functions or closures.
  • Easily define and execute commands.
  • Implement optional command arguments.
  • Redirect output to types that implement io::Write.

Overview

rusty-cmd provides two modules:

  • cmd: Used for creating the Cmd struct that contains the CommandHandler implementations in a HashMap.
  • command_handler: Contains the CommandHandler trait.

Example

use std::io;
use std::io::Write;

use rusty_cmd::cmd::Cmd;
use rusty_cmd::command_handler::{CommandHandler, CommandResult};
use rusty_cmd::handlers::Quit;

/// CommandHandler that prints out help message
#[derive(Default)]
pub struct Help;

impl<W> CommandHandler<W> for Help
where
    W: std::io::Write,
{
    fn execute(&self, output: &mut W, _args: &[&str]) -> CommandResult {
        writeln!(output, "Help message").expect("Should be able to write to output");
        CommandResult::Continue
    }
}

/// CommandHandler that emulates the basic bash touch command to create a new file
#[derive(Default)]
pub struct Touch;

impl<W> CommandHandler<W> for Touch
where
    W: std::io::Write,
{
    fn execute(&self, output: &mut W, _args: &[&str]) -> CommandResult {
        let option_filename = _args.first();

        match option_filename {
            Some(filename) => {
                let fs_result = std::fs::File::create(filename);
                match fs_result {
                    Ok(file) => writeln!(output, "Created file: {:?}", file)
                        .expect("Should be able to write to output"),
                    Err(_) => writeln!(output, "Could not create file: {}", filename)
                        .expect("Should be able to write to output"),
                }
            }
            None => println!("Need to specify a filename"),
        }
        CommandResult::Continue
    }
}

fn main() -> Result<(), std::io::Error> {
    let mut cmd = Cmd::new(io::BufReader::new(io::stdin()), io::stdout());

    let help = Help;
    let hello = Touch;
    let quit = Quit::default();

    cmd.add_cmd(String::from("help"), help)?;
    cmd.add_cmd(String::from("touch"), hello)?;
    cmd.add_cmd_fn(String::from("greet"), |output, _args| {
        writeln!(output, "hello!").expect("Should be able to write to output");
        CommandResult::Continue
    })?;
    cmd.add_cmd(String::from("quit"), quit)?;

    cmd.run()?;

    Ok(())
}

Usage

To use rusty-cmd in your project, add the following to your Cargo.toml file:

[dependencies]
rusty-cmd = "2.0.0"

Then import the crate in your Rust code:

use rusty_cmd::command_handler::{CommandHandler, CommandResult};
use rusty_cmd::cmd::Cmd;

Contributing

We welcome contributions! See our CONTIBUTING guide

Contributors ✨

Miguel Alizo
Miguel Alizo

🦀✅
John Aughey
John Aughey

🦀✅

License

This project is licensed under the MIT License - see the LICENSE file for details.

No runtime deps