Struct CliBuilder 

pub struct CliBuilder { /* private fields */ }

Fluent builder for creating CLI/REPL applications

Provides a chainable API for configuring and building applications. Automatically loads configuration, registers handlers, and creates the appropriate interface (CLI or REPL).

Builder Pattern

The builder follows the standard Rust builder pattern:

• Methods consume self and return Self
• Final build() method consumes the builder and returns the app

Example

use dynamic_cli::prelude::*;

let app = CliBuilder::new()
    .config_file("commands.yaml")
    .context(Box::new(MyContext::default()))
    .register_handler("my_handler", Box::new(MyHandler))
    .prompt("myapp")
    .build()?;

Implementations

impl CliBuilder

pub fn new() -> Self

Create a new builder

Example

use dynamic_cli::CliBuilder;

let builder = CliBuilder::new();

pub fn config_file<P: Into<PathBuf>>(self, path: P) -> Self

Specify the configuration file

The file will be loaded during build(). Supports YAML and JSON formats.

Arguments

• path - Path to the configuration file (.yaml, .yml, or .json)

Example

use dynamic_cli::CliBuilder;

let builder = CliBuilder::new()
    .config_file("commands.yaml");

pub fn config(self, config: CommandsConfig) -> Self

Provide a pre-loaded configuration

Use this instead of config_file() if you want to load and potentially modify the configuration before building.

Arguments

• config - Loaded and validated configuration

Example

use dynamic_cli::{CliBuilder, config::loader::load_config};

let mut config = load_config("commands.yaml")?;
// Modify config if needed...

let builder = CliBuilder::new()
    .config(config);

pub fn context(self, context: Box<dyn ExecutionContext>) -> Self

Set the execution context

The context will be passed to all command handlers and can store application state.

Arguments

• context - Boxed execution context implementing ExecutionContext

Example

use dynamic_cli::prelude::*;

#[derive(Default)]
struct MyContext {
    count: u32,
}

impl ExecutionContext for MyContext {
    fn as_any(&self) -> &dyn std::any::Any { self }
    fn as_any_mut(&mut self) -> &mut dyn std::any::Any { self }
}

let builder = CliBuilder::new()
    .context(Box::new(MyContext::default()));

pub fn register_handler( self, name: impl Into<String>, handler: Box<dyn CommandHandler>, ) -> Self

Register a command handler

Associates a handler with the command’s implementation name from the config. The name must match the implementation field in the command definition.

Arguments

• name - Implementation name from the configuration
• handler - Boxed command handler implementing CommandHandler

Example

use dynamic_cli::prelude::*;
use std::collections::HashMap;

struct MyCommand;

impl CommandHandler for MyCommand {
    fn execute(
        &self,
        _ctx: &mut dyn ExecutionContext,
        _args: &HashMap<String, String>,
    ) -> dynamic_cli::Result<()> {
        println!("Executed!");
        Ok(())
    }
}

let builder = CliBuilder::new()
    .register_handler("my_command", Box::new(MyCommand));

pub fn prompt(self, prompt: impl Into<String>) -> Self

Set the REPL prompt

Only used in REPL mode. If not specified, uses the prompt from the configuration or defaults to “cli”.

Arguments

• prompt - Prompt prefix (e.g., “myapp” displays as “myapp > “)

Example

use dynamic_cli::CliBuilder;

let builder = CliBuilder::new()
    .prompt("myapp");

pub fn build(self) -> Result<CliApp>

Build the application

Performs the following steps:

1. Load configuration (if config_file() was used)
2. Validate that a context was provided
3. Create the command registry
4. Register all command handlers
5. Verify that all required commands have handlers
6. Create the CliApp

Returns

A configured CliApp ready to run

Errors

• Configuration errors (file not found, invalid format, etc.)
• Missing context
• Missing required handlers
• Registry errors

Example

use dynamic_cli::prelude::*;

let app = CliBuilder::new()
    .config_file("commands.yaml")
    .context(Box::new(MyContext::default()))
    .register_handler("handler", Box::new(MyHandler))
    .build()?;

// Now app is ready to run

Trait Implementations

impl Default for CliBuilder

fn default() -> Self

Returns the “default value” for a type.