clippy_lints/src/utils/camel_case.rs

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