clippy_lints/src/utils/camel_case.rs

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