sanitize

Author: burrbull

src/util.rs

@@ -69,31 +69,6 @@ pub enum Case {
 }
 
 impl Case {
-    pub fn to_case<'a>(&self, s: &'a str) -> Cow<'a, str> {
-        match self {
-            Self::Constant => {
-                if s.is_constant_case() {
-                    s.into()
-                } else {
-                    s.to_constant_case().into()
-                }
-            }
-            Self::Pascal => {
-                if s.is_pascal_case() {
-                    s.into()
-                } else {
-                    s.to_pascal_case().into()
-                }
-            }
-            Self::Snake => {
-                if s.is_snake_case() {
-                    s.into()
-                } else {
-                    s.to_snake_case().into()
-                }
-            }
-        }
-    }
     pub fn cow_to_case<'a>(&self, cow: Cow<'a, str>) -> Cow<'a, str> {
         match self {
             Self::Constant => match cow {
@@ -110,6 +85,15 @@ impl Case {
             },
         }
     }
+    pub fn sanitize<'a>(&self, s: &'a str) -> Cow<'a, str> {
+        let s = if s.contains(BLACKLIST_CHARS) {
+            Cow::Owned(s.replace(BLACKLIST_CHARS, ""))
+        } else {
+            s.into()
+        };
+
+        self.cow_to_case(s)
+    }
 }
 
 fn current_dir() -> PathBuf {
@@ -244,48 +228,31 @@ pub trait ToSanitizedCase {
 
 impl ToSanitizedCase for str {
     fn to_sanitized_pascal_case(&self) -> Cow<str> {
-        let s = if self.contains(BLACKLIST_CHARS) {
-            Cow::Owned(self.replace(BLACKLIST_CHARS, ""))
-        } else {
-            self.into()
-        };
-
+        let s = Case::Pascal.sanitize(self);
         if s.as_bytes().get(0).unwrap_or(&0).is_ascii_digit() {
-            Cow::from(format!("_{}", Case::Pascal.to_case(&s)))
+            Cow::from(format!("_{}", s))
         } else {
-            Case::Pascal.cow_to_case(s)
+            s
         }
     }
     fn to_sanitized_constant_case(&self) -> Cow<str> {
-        let s = if self.contains(BLACKLIST_CHARS) {
-            Cow::Owned(self.replace(BLACKLIST_CHARS, ""))
-        } else {
-            self.into()
-        };
-
+        let s = Case::Constant.sanitize(self);
         if s.as_bytes().get(0).unwrap_or(&0).is_ascii_digit() {
-            Cow::from(format!("_{}", Case::Constant.to_case(&s)))
+            Cow::from(format!("_{}", s))
         } else {
-            Case::Constant.cow_to_case(s)
+            s
         }
     }
     fn to_sanitized_not_keyword_snake_case(&self) -> Cow<str> {
         const INTERNALS: [&str; 4] = ["set_bit", "clear_bit", "bit", "bits"];
 
-        let s = if self.contains(BLACKLIST_CHARS) {
-            Cow::Owned(self.replace(BLACKLIST_CHARS, ""))
-        } else {
-            self.into()
-        };
+        let s = Case::Snake.sanitize(self);
         if s.as_bytes().get(0).unwrap_or(&0).is_ascii_digit() {
-            format!("_{}", Case::Snake.to_case(&s)).into()
+            format!("_{}", s).into()
+        } else if INTERNALS.contains(&s.as_ref()) {
+            s + "_"
         } else {
-            let s = Case::Snake.cow_to_case(s);
-            if INTERNALS.contains(&s.as_ref()) {
-                s + "_"
-            } else {
-                s
-            }
+            s
         }
     }
 }