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