src/tools/clippy/clippy_lints/src/utils/camel_case.rs

   1 /// Returns the index of the character after the first camel-case component of `s`.
   2 #[must_use]
   3 pub fn until(s: &str) -> usize {
   4     let mut iter = s.char_indices();
   5     if let Some((_, first)) = iter.next() {
   6         if !first.is_uppercase() {
   7             return 0;
   8         }
   9     } else {
  10         return 0;
  11     }
  12     let mut up = true;
  13     let mut last_i = 0;
  14     for (i, c) in iter {
  15         if up {
  16             if c.is_lowercase() {
  17                 up = false;
  18             } else {
  19                 return last_i;
  20             }
  21         } else if c.is_uppercase() {
  22             up = true;
  23             last_i = i;
  24         } else if !c.is_lowercase() {
  25             return i;
  26         }
  27     }
  28     if up {
  29         last_i
  30     } else {
  31         s.len()
  32     }
  33 }
  34
  35 /// Returns index of the last camel-case component of `s`.
  36 #[must_use]
  37 pub fn from(s: &str) -> usize {
  38     let mut iter = s.char_indices().rev();
  39     if let Some((_, first)) = iter.next() {
  40         if !first.is_lowercase() {
  41             return s.len();
  42         }
  43     } else {
  44         return s.len();
  45     }
  46     let mut down = true;
  47     let mut last_i = s.len();
  48     for (i, c) in iter {
  49         if down {
  50             if c.is_uppercase() {
  51                 down = false;
  52                 last_i = i;
  53             } else if !c.is_lowercase() {
  54                 return last_i;
  55             }
  56         } else if c.is_lowercase() {
  57             down = true;
  58         } else {
  59             return last_i;
  60         }
  61     }
  62     last_i
  63 }
  64
  65 #[cfg(test)]
  66 mod test {
  67     use super::{from, until};
  68
  69     #[test]
  70     fn from_full() {
  71         assert_eq!(from("AbcDef"), 0);
  72         assert_eq!(from("Abc"), 0);
  73     }
  74
  75     #[test]
  76     fn from_partial() {
  77         assert_eq!(from("abcDef"), 3);
  78         assert_eq!(from("aDbc"), 1);
  79     }
  80
  81     #[test]
  82     fn from_not() {
  83         assert_eq!(from("AbcDef_"), 7);
  84         assert_eq!(from("AbcDD"), 5);
  85     }
  86
  87     #[test]
  88     fn from_caps() {
  89         assert_eq!(from("ABCD"), 4);
  90     }
  91
  92     #[test]
  93     fn until_full() {
  94         assert_eq!(until("AbcDef"), 6);
  95         assert_eq!(until("Abc"), 3);
  96     }
  97
  98     #[test]
  99     fn until_not() {
 100         assert_eq!(until("abcDef"), 0);
 101         assert_eq!(until("aDbc"), 0);
 102     }
 103
 104     #[test]
 105     fn until_partial() {
 106         assert_eq!(until("AbcDef_"), 6);
 107         assert_eq!(until("CallTypeC"), 8);
 108         assert_eq!(until("AbcDD"), 3);
 109     }
 110
 111     #[test]
 112     fn until_caps() {
 113         assert_eq!(until("ABCD"), 0);
 114     }
 115 }