Enum RegistryError 

pub enum RegistryError {
    DuplicateRegistration {
        name: String,
        suggestion: Option<String>,
    },
    DuplicateAlias {
        alias: String,
        existing_command: String,
        suggestion: Option<String>,
    },
    MissingHandler {
        command: String,
        suggestion: Option<String>,
    },
    FaultToleranceMismatch {
        command: String,
        expected: bool,
        configured: bool,
        suggestion: Option<String>,
    },
}

Errors related to the command registry

These errors occur when registering commands and handlers in the registry.

Variants

DuplicateRegistration

Attempt to register an already existing command

Example

use dynamic_cli::error::RegistryError;

let error = RegistryError::DuplicateRegistration {
    name: "run".to_string(),
    suggestion: Some("Command names must be unique across the registry.".to_string()),
};
let msg = format!("{}", error);
assert!(msg.contains("run"));

Fields

name: String

suggestion: Option<String>

Actionable hint surfaced to the user (not part of the Display string)

DuplicateAlias

Alias already used by another command

Example

use dynamic_cli::error::RegistryError;

let error = RegistryError::DuplicateAlias {
    alias: "r".to_string(),
    existing_command: "run".to_string(),
    suggestion: Some("Choose a different alias for one of the commands.".to_string()),
};
let msg = format!("{}", error);
assert!(msg.contains("run"));

Fields

alias: String

existing_command: String

suggestion: Option<String>

Actionable hint surfaced to the user (not part of the Display string)

MissingHandler

Missing handler for a definition

A command is defined in the config but no handler has been registered for it.

Example

use dynamic_cli::error::RegistryError;

let error = RegistryError::MissingHandler {
    command: "export".to_string(),
    suggestion: Some(
        "Call .register_sync_handler(\"export\", ...) before running.".to_string()
    ),
};
let msg = format!("{}", error);
assert!(msg.contains("export"));

Fields

command: String

suggestion: Option<String>

Actionable hint surfaced to the user (not part of the Display string)

FaultToleranceMismatch

A handler’s declared expected_fault_tolerance() contradicts the command’s configured continue_on_failure

Raised by CommandRegistry::register_sync/register_async when the handler expresses an opinion (Some(bool)) that disagrees with the YAML value — catching a misconfiguration at startup rather than at first use in a chain. Never raised when the handler expresses no opinion (None, the default).

Example

use dynamic_cli::error::RegistryError;

let error = RegistryError::FaultToleranceMismatch {
    command: "solve".to_string(),
    expected: false,
    configured: true,
    suggestion: Some(
        "set `continue_on_failure: false` for command 'solve' in the \
         YAML config, matching what its handler expects".to_string()
    ),
};
let msg = format!("{}", error);
assert!(msg.contains("solve"));

Fields

command: String

expected: bool

What the handler’s expected_fault_tolerance() returned (Some side)

configured: bool

What CommandDefinition::continue_on_failure is actually set to

suggestion: Option<String>

Actionable hint surfaced to the user (not part of the Display string)

Implementations

impl RegistryError

pub fn missing_handler(command: &str) -> Self

Create a missing-handler error with an actionable suggestion

The suggestion interpolates the command name so the user knows exactly which .register_sync_handler() call is missing.

Example

use dynamic_cli::error::RegistryError;

let error = RegistryError::missing_handler("export");
match error {
    RegistryError::MissingHandler { suggestion, .. } => {
        assert!(suggestion.as_deref().unwrap_or("").contains("export"));
    }
    _ => panic!("wrong variant"),
}

pub fn fault_tolerance_mismatch( command: &str, expected: bool, configured: bool, ) -> Self

Create a fault-tolerance-mismatch error with an actionable suggestion

expected is what the handler’s expected_fault_tolerance() returned; configured is the command’s actual CommandDefinition::continue_on_failure. The suggestion tells the user exactly which YAML value to change to resolve the contradiction.

Example

use dynamic_cli::error::RegistryError;

let error = RegistryError::fault_tolerance_mismatch("solve", false, true);
match error {
    RegistryError::FaultToleranceMismatch { suggestion, .. } => {
        assert!(suggestion.as_deref().unwrap_or("").contains("continue_on_failure: false"));
    }
    _ => panic!("wrong variant"),
}

Trait Implementations

impl Debug for RegistryError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for RegistryError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for RegistryError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<RegistryError> for DynamicCliError

fn from(source: RegistryError) -> Self

Converts to this type from the input type.