clippy_lints/src/utils/camel_case.rs

   1 // Copyright 2014-2018 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution.
   3 //
   4 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   5 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   6 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   7 // option. This file may not be copied, modified, or distributed
   8 // except according to those terms.
   9
  10
  11 /// Return the index of the character after the first camel-case component of
  12 /// `s`.
  13 pub fn camel_case_until(s: &str) -> usize {
  14     let mut iter = s.char_indices();
  15     if let Some((_, first)) = iter.next() {
  16         if !first.is_uppercase() {
  17             return 0;
  18         }
  19     } else {
  20         return 0;
  21     }
  22     let mut up = true;
  23     let mut last_i = 0;
  24     for (i, c) in iter {
  25         if up {
  26             if c.is_lowercase() {
  27                 up = false;
  28             } else {
  29                 return last_i;
  30             }
  31         } else if c.is_uppercase() {
  32             up = true;
  33             last_i = i;
  34         } else if !c.is_lowercase() {
  35             return i;
  36         }
  37     }
  38     if up {
  39         last_i
  40     } else {
  41         s.len()
  42     }
  43 }
  44
  45 /// Return index of the last camel-case component of `s`.
  46 pub fn camel_case_from(s: &str) -> usize {
  47     let mut iter = s.char_indices().rev();
  48     if let Some((_, first)) = iter.next() {
  49         if !first.is_lowercase() {
  50             return s.len();
  51         }
  52     } else {
  53         return s.len();
  54     }
  55     let mut down = true;
  56     let mut last_i = s.len();
  57     for (i, c) in iter {
  58         if down {
  59             if c.is_uppercase() {
  60                 down = false;
  61                 last_i = i;
  62             } else if !c.is_lowercase() {
  63                 return last_i;
  64             }
  65         } else if c.is_lowercase() {
  66             down = true;
  67         } else {
  68             return last_i;
  69         }
  70     }
  71     last_i
  72 }
  73
  74 #[cfg(test)]
  75 mod test {
  76     use super::{camel_case_from, camel_case_until};
  77
  78     #[test]
  79     fn from_full() {
  80         assert_eq!(camel_case_from("AbcDef"), 0);
  81         assert_eq!(camel_case_from("Abc"), 0);
  82     }
  83
  84     #[test]
  85     fn from_partial() {
  86         assert_eq!(camel_case_from("abcDef"), 3);
  87         assert_eq!(camel_case_from("aDbc"), 1);
  88     }
  89
  90     #[test]
  91     fn from_not() {
  92         assert_eq!(camel_case_from("AbcDef_"), 7);
  93         assert_eq!(camel_case_from("AbcDD"), 5);
  94     }
  95
  96     #[test]
  97     fn from_caps() {
  98         assert_eq!(camel_case_from("ABCD"), 4);
  99     }
 100
 101     #[test]
 102     fn until_full() {
 103         assert_eq!(camel_case_until("AbcDef"), 6);
 104         assert_eq!(camel_case_until("Abc"), 3);
 105     }
 106
 107     #[test]
 108     fn until_not() {
 109         assert_eq!(camel_case_until("abcDef"), 0);
 110         assert_eq!(camel_case_until("aDbc"), 0);
 111     }
 112
 113     #[test]
 114     fn until_partial() {
 115         assert_eq!(camel_case_until("AbcDef_"), 6);
 116         assert_eq!(camel_case_until("CallTypeC"), 8);
 117         assert_eq!(camel_case_until("AbcDD"), 3);
 118     }
 119
 120     #[test]
 121     fn until_caps() {
 122         assert_eq!(camel_case_until("ABCD"), 0);
 123     }
 124 }