ito-common 0.1.33

Common utilities and error types for Ito
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
134
135
136
137

//! Identifier parsing and lightweight ID heuristics.

mod change_id;
mod error;
mod module_id;
mod spec_id;
pub(crate) mod sub_module_id;

pub use change_id::parse_change_id;
pub use change_id::{ChangeId, ParsedChangeId};
pub use error::IdParseError;
pub use module_id::parse_module_id;
pub use module_id::{ModuleId, ParsedModuleId};
pub use spec_id::parse_spec_id;
pub use spec_id::{ParsedSpecId, SpecId};
pub use sub_module_id::parse_sub_module_id;
pub use sub_module_id::{ParsedSubModuleId, SubModuleId};

/// Returns `true` when `s` is non-empty and contains only ASCII digits.
///
/// Used by the ID parsers to validate numeric segments without allocating.
pub(crate) fn is_all_ascii_digits(s: &str) -> bool {
    if s.is_empty() {
        return false;
    }
    for c in s.chars() {
        if !c.is_ascii_digit() {
            return false;
        }
    }
    true
}

/// The kind of an Ito identifier, as determined by [`classify_id`].
///
/// Use this when you need to route an opaque user-supplied string to the
/// correct parser without attempting a full parse first.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ItoIdKind {
    /// A module identifier: `NNN` or `NNN_name` (e.g., `"005"`, `"005_dev-tooling"`).
    ModuleId,
    /// A sub-module identifier: `NNN.SS` or `NNN.SS_name` (e.g., `"005.01"`).
    SubModuleId,
    /// A change identifier in the legacy module format: `NNN-NN_name` (e.g., `"005-01_my-change"`).
    ModuleChangeId,
    /// A change identifier in the sub-module format: `NNN.SS-NN_name` (e.g., `"005.01-03_my-change"`).
    SubModuleChangeId,
}

/// Classify an opaque identifier string into one of the four [`ItoIdKind`] variants.
///
/// This is a lightweight structural heuristic. It does **not** validate the
/// identifier; use the appropriate `parse_*` function for full validation.
///
/// The classification inspects the portion of the string **before** the first
/// `_` (the name separator), so hyphens inside name suffixes (e.g.,
/// `005_dev-tooling`) do not affect the result.
///
/// | Prefix structure         | Kind                |
/// |--------------------------|---------------------|
/// | `NNN.SS-NN`              | `SubModuleChangeId` |
/// | `NNN.SS`                 | `SubModuleId`       |
/// | `NNN-NN`                 | `ModuleChangeId`    |
/// | `NNN`                    | `ModuleId`          |
pub fn classify_id(input: &str) -> ItoIdKind {
    // Inspect only the prefix before the first `_` so that hyphens inside
    // name suffixes (e.g., "005_dev-tooling") do not affect classification.
    let prefix = match input.split_once('_') {
        Some((left, _)) => left,
        None => input,
    };

    let has_dot = prefix.contains('.');
    let has_hyphen = prefix.contains('-');

    if has_dot && has_hyphen {
        ItoIdKind::SubModuleChangeId
    } else if has_dot {
        ItoIdKind::SubModuleId
    } else if has_hyphen {
        ItoIdKind::ModuleChangeId
    } else {
        ItoIdKind::ModuleId
    }
}

/// Quick heuristic used by CLI prompts to detect a likely change id.
///
/// Returns `true` for both legacy `NNN-NN_name` and sub-module `NNN.SS-NN_name`
/// formats.
pub fn looks_like_change_id(input: &str) -> bool {
    let input = input.trim();
    if input.is_empty() {
        return false;
    }

    let mut digit_prefix_len = 0usize;
    let mut has_hyphen = false;
    let mut has_underscore = false;

    for ch in input.chars() {
        if ch.is_ascii_digit() && digit_prefix_len == 0 {
            digit_prefix_len = 1;
            continue;
        }

        if ch.is_ascii_digit() && digit_prefix_len > 0 {
            digit_prefix_len += 1;
            continue;
        }

        if digit_prefix_len == 0 {
            break;
        }

        match ch {
            '-' => has_hyphen = true,
            '_' => has_underscore = true,
            '.' => {}
            _ => {}
        }
    }

    digit_prefix_len > 0 && has_hyphen && has_underscore
}

/// Quick heuristic used by CLI prompts to detect a likely module id.
pub fn looks_like_module_id(input: &str) -> bool {
    let input = input.trim();
    let Some(first) = input.chars().next() else {
        return false;
    };
    first.is_ascii_digit()
}

#[cfg(test)]
mod id_tests;