cc622608db
`must_use_unit` lints unit-returning functions with a `#[must_use]` attribute, suggesting to remove it. `double_must_use` lints functions with a plain `#[must_use]` attribute, but which return a type which is already `#[must_use]`, so the attribute has no benefit. `must_use_candidate` is a pedantic lint that lints functions and methods that return some non-unit type that is not already `#[must_use]` and suggests to add the annotation.
116 lines
2.4 KiB
Rust
116 lines
2.4 KiB
Rust
/// Returns the index of the character after the first camel-case component of `s`.
|
|
#[must_use]
|
|
pub fn until(s: &str) -> usize {
|
|
let mut iter = s.char_indices();
|
|
if let Some((_, first)) = iter.next() {
|
|
if !first.is_uppercase() {
|
|
return 0;
|
|
}
|
|
} else {
|
|
return 0;
|
|
}
|
|
let mut up = true;
|
|
let mut last_i = 0;
|
|
for (i, c) in iter {
|
|
if up {
|
|
if c.is_lowercase() {
|
|
up = false;
|
|
} else {
|
|
return last_i;
|
|
}
|
|
} else if c.is_uppercase() {
|
|
up = true;
|
|
last_i = i;
|
|
} else if !c.is_lowercase() {
|
|
return i;
|
|
}
|
|
}
|
|
if up {
|
|
last_i
|
|
} else {
|
|
s.len()
|
|
}
|
|
}
|
|
|
|
/// Returns index of the last camel-case component of `s`.
|
|
#[must_use]
|
|
pub fn from(s: &str) -> usize {
|
|
let mut iter = s.char_indices().rev();
|
|
if let Some((_, first)) = iter.next() {
|
|
if !first.is_lowercase() {
|
|
return s.len();
|
|
}
|
|
} else {
|
|
return s.len();
|
|
}
|
|
let mut down = true;
|
|
let mut last_i = s.len();
|
|
for (i, c) in iter {
|
|
if down {
|
|
if c.is_uppercase() {
|
|
down = false;
|
|
last_i = i;
|
|
} else if !c.is_lowercase() {
|
|
return last_i;
|
|
}
|
|
} else if c.is_lowercase() {
|
|
down = true;
|
|
} else {
|
|
return last_i;
|
|
}
|
|
}
|
|
last_i
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test {
|
|
use super::{from, until};
|
|
|
|
#[test]
|
|
fn from_full() {
|
|
assert_eq!(from("AbcDef"), 0);
|
|
assert_eq!(from("Abc"), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn from_partial() {
|
|
assert_eq!(from("abcDef"), 3);
|
|
assert_eq!(from("aDbc"), 1);
|
|
}
|
|
|
|
#[test]
|
|
fn from_not() {
|
|
assert_eq!(from("AbcDef_"), 7);
|
|
assert_eq!(from("AbcDD"), 5);
|
|
}
|
|
|
|
#[test]
|
|
fn from_caps() {
|
|
assert_eq!(from("ABCD"), 4);
|
|
}
|
|
|
|
#[test]
|
|
fn until_full() {
|
|
assert_eq!(until("AbcDef"), 6);
|
|
assert_eq!(until("Abc"), 3);
|
|
}
|
|
|
|
#[test]
|
|
fn until_not() {
|
|
assert_eq!(until("abcDef"), 0);
|
|
assert_eq!(until("aDbc"), 0);
|
|
}
|
|
|
|
#[test]
|
|
fn until_partial() {
|
|
assert_eq!(until("AbcDef_"), 6);
|
|
assert_eq!(until("CallTypeC"), 8);
|
|
assert_eq!(until("AbcDD"), 3);
|
|
}
|
|
|
|
#[test]
|
|
fn until_caps() {
|
|
assert_eq!(until("ABCD"), 0);
|
|
}
|
|
}
|