fli 1.2.2

The commander.js like CLI Parser for rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133

use thiserror::Error;

use crate::command::FliCommand;

/// Errors that can occur during CLI parsing and execution
#[derive(Debug, Error)]
pub enum FliError {
    /// Command name doesn't match expected command
    #[error("Command mismatch: expected '{expected}', got '{actual}'")]
    CommandMismatch { expected: String, actual: String },

    /// Unknown subcommand was specified
    #[error("Unknown command: '{0}'. Run with --help to see available commands")]
    UnknownCommand(String, Vec<String>),

    /// Unknown option flag was provided
    #[error("Unknown option: '{0}'. Run with --help to see available options")]
    UnknownOption(String),

    // ==================== Value Errors ====================
    /// Required option value is missing
    #[error("Missing required value for option '{option}'")]
    MissingValue { option: String },

    /// Option expects no value but one was provided
    #[error("Option '{option}' does not accept values, but '{value}' was provided")]
    UnexpectedValue { option: String, value: String },

    /// Wrong number of values provided
    #[error("Option '{option}' expected {expected} value(s), got {actual}")]
    ValueCountMismatch {
        option: String,
        expected: usize,
        actual: usize,
    },

    /// Value parsing failed (e.g., string to int)
    #[error("Invalid value '{value}' for option '{option}': {reason}")]
    InvalidValue {
        option: String,
        value: String,
        reason: String,
    },

    /// Value type parsing failed
    #[error("Failed to parse '{value}' as {expected_type}: {reason}")]
    ValueParseError {
        value: String,
        expected_type: String,
        reason: String,
    },

    // ==================== State Errors ====================
    /// Invalid state transition during parsing
    #[error("Invalid parse state transition from {from:?} to {to:?}")]
    InvalidStateTransition { from: String, to: String },

    /// Unexpected token at position
    #[error("Unexpected '{token}' at position {position}")]
    UnexpectedToken { token: String, position: usize },

    // ==================== Configuration Errors ====================
    /// Option configuration is invalid
    #[error("Invalid option configuration for '{option}': {reason}")]
    InvalidOptionConfig { option: String, reason: String },

    /// Command configuration is invalid
    #[error("Invalid command configuration: {0}")]
    InvalidCommandConfig(String),

    /// Option flag format is invalid
    #[error("Invalid flag format: '{flag}'. Flags must start with '-' or '--'")]
    InvalidFlagFormat { flag: String },

    // ==================== Runtime Errors ====================
    /// Option was not found in parser
    #[error("Option '{0}' not found in parser")]
    OptionNotFound(String),

    /// Parser not prepared before use
    #[error("Parser must be prepared before use. Call prepare() first")]
    ParserNotPrepared,

    // ==================== Generic Errors ====================
    /// Internal error (shouldn't happen in normal usage)
    #[error("Internal error: {0}")]
    Internal(String),
    /// Invalid command usage (e.g., wrong flags or operands)
    #[error("Invalid usage: {0}. Run with --help to see correct usage")]
    InvalidUsage(String),
}

impl FliError {
    /// Creates a command mismatch error
    pub fn command_mismatch(expected: impl Into<String>, actual: impl Into<String>) -> Self {
        Self::CommandMismatch {
            expected: expected.into(),
            actual: actual.into(),
        }
    }

    /// Creates a missing value error
    pub fn missing_value(option: impl Into<String>) -> Self {
        Self::MissingValue {
            option: option.into(),
        }
    }

    /// Creates an invalid value error
    pub fn invalid_value(
        option: impl Into<String>,
        value: impl Into<String>,
        reason: impl Into<String>,
    ) -> Self {
        Self::InvalidValue {
            option: option.into(),
            value: value.into(),
            reason: reason.into(),
        }
    }

    /// Creates a value count mismatch error
    pub fn value_count_mismatch(option: impl Into<String>, expected: usize, actual: usize) -> Self {
        Self::ValueCountMismatch {
            option: option.into(),
            expected,
            actual,
        }
    }
}

/// Type alias for Results using FliError
pub type Result<T> = std::result::Result<T, FliError>;