fixup! champion.rs build.rs proof of concept

Author: MingweiSamuel

.gitignore

@@ -2,4 +2,3 @@
 **/*.rs.bk
 /doc
 apikey.txt
-

riven/build/champion.rs

@@ -126,29 +126,6 @@ pub fn champion() -> File {
                         _ => None,
                     }
                 }
-
-                /// https://github.com/MingweiSamuel/Riven/issues/36
-                pub(crate) fn serialize_result<S>(
-                    val: &Result<Self, std::num::TryFromIntError>,
-                    serializer: S,
-                ) -> Result<S::Ok, S::Error>
-                where
-                    S: serde::ser::Serializer,
-                {
-                    use serde::ser::Serialize;
-                    val.unwrap_or(Champion(-1)).serialize(serializer)
-                }
-
-                /// https://github.com/MingweiSamuel/Riven/issues/36
-                pub(crate) fn deserialize_result<'de, D>(
-                    deserializer: D,
-                ) -> Result<Result<Self, std::num::TryFromIntError>, D::Error>
-                where
-                    D: serde::de::Deserializer<'de>,
-                {
-                    use std::convert::TryInto;
-                    <i64 as serde::de::Deserialize>::deserialize(deserializer).map(|id| id.try_into().map(Self))
-                }
             }
         }
     };
@@ -158,14 +135,14 @@ pub fn champion() -> File {
             .iter()
             .flat_map(|champion| {
                 IntoIterator::into_iter([&champion.alias, &champion.name]).flat_map(move |s| {
+                    // e.g. `CHOG` for `Cho'Gath`.
                     let chars_full = s.chars().filter(|c| c.is_ascii_alphanumeric());
+                    // e.g. `CHO` for `Cho'Gath`.
                     let chars_first = s.chars().take_while(|c| c.is_ascii_alphanumeric());
-                    let chars_word = s.chars().take_while(|c| c.is_ascii_alphabetic());
 
                     IntoIterator::into_iter([
                         Box::new(chars_full) as Box<dyn Iterator<Item = char>>,
                         Box::new(chars_first),
-                        Box::new(chars_word),
                     ])
                     .map(move |chars| {
                         let str: String = chars
@@ -187,21 +164,6 @@ pub fn champion() -> File {
         });
 
         quote! {
-            /// The error used for failures in [`Champion`]'s
-            /// [`FromStr`](std::str::FromStr) implementation.
-            ///
-            /// Currently only internally stores the four characters used to parse the
-            /// champion, but may change in the future.
-            #[derive(Debug)]
-            pub struct ParseChampionError([char; 4]);
-            impl std::fmt::Display for ParseChampionError {
-                fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-                    let s: String = self.0.iter().copied().take_while(|&c| '\0' != c).collect();
-                    write!(f, "Failed to parse unknown champion prefix: {:?}", s)
-                }
-            }
-            impl std::error::Error for ParseChampionError {}
-
             impl std::str::FromStr for Champion {
                 type Err = ParseChampionError;
                 fn from_str(s: &str) -> Result<Self, Self::Err> {
@@ -218,13 +180,6 @@ pub fn champion() -> File {
                     }
                 }
             }
-
-            impl std::convert::TryFrom<&str> for Champion {
-                type Error = <Self as std::str::FromStr>::Err;
-                fn try_from(value: &str) -> Result<Self, Self::Error> {
-                    <Self as std::str::FromStr>::from_str(value)
-                }
-            }
         }
     };