champion.rs build.rs proof of concept

Author: MingweiSamuel

.gitignore

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

Cargo.lock

@@ -8,9 +8,10 @@ readme = "../README.md"
 license = "MIT"
 edition = "2018"
 rust-version = "1.71.1"
-include = ["src/**", "../README.md", "/examples"]
+include = ["src/**", "schemas", "build", "examples", "../README.md"]
 keywords = ["riot-games", "riot", "league", "league-of-legends"]
 categories = ["api-bindings", "web-programming::http-client", "wasm"]
+build = "build/main.rs"
 
 [lib]
 crate-type = ["cdylib", "rlib"]
@@ -90,3 +91,13 @@ console_error_panic_hook = "0.1"
 console_log = "1.0"
 wasm-bindgen = "0.2.70"
 wasm-bindgen-test = "0.3"
+
+[build-dependencies]
+heck = "0.5.0"
+prettyplease = "0.2.30"
+proc-macro2 = "1.0.93"
+quote = "1.0.38"
+serde = { version = "1.0.85", features = ["derive"] }
+serde_derive = "1.0.85"
+serde_json = "1.0.1"
+syn = "2.0.96"

riven/Cargo.toml

@@ -0,0 +1,191 @@
+use std::collections::BTreeMap;
+
+use heck::ToShoutySnakeCase;
+use proc_macro2::{Ident, Literal, Span};
+use quote::quote;
+use syn::{parse_quote, File};
+
+/// ```json
+/// {
+///     "id": 910,
+///     "name": "Hwei",
+///     "alias": "Hwei",
+///     "squarePortraitPath": "/lol-game-data/assets/v1/champion-icons/910.png",
+///     "roles": [
+///         "mage",
+///         "support"
+///     ]
+/// }
+/// ```
+#[derive(serde::Deserialize)]
+#[allow(dead_code)]
+pub struct Champion {
+    pub id: i16,
+    pub name: String,
+    pub alias: String,
+    pub square_portrait_path: Option<String>,
+    pub roles: Vec<String>,
+}
+
+pub fn champion() -> File {
+    let mut champions: Vec<Champion> =
+        serde_json::from_str(include_str!("../schemas/.champion.json")).unwrap();
+    champions.retain(|champion| champion.id >= 0);
+
+    let newtype_enum = {
+        let doc_rows = champions.iter().map(|champion| {
+            let id = champion.id;
+            let name = &champion.name;
+            let alias = &champion.alias;
+            format!("`{}` | {} | {} | {}", id, name, alias, id)
+        });
+
+        let variants = champions.iter().map(|champion| {
+            let doc = format!("`{}`", champion.id);
+            let ident = Ident::new(&champion.alias.to_shouty_snake_case(), Span::call_site());
+            let id = Literal::i16_unsuffixed(champion.id);
+            quote! {
+                #[doc = #doc]
+                #ident = #id,
+            }
+        });
+
+        quote! {
+            newtype_enum! {
+                /// A League of Legends champion.
+                ///
+                /// This newtype acts as a C-like enum; each variant corresponds to an
+                /// integer value. Using a newtype allows _unknown_ variants to be
+                /// represented. This is important when Riot adds new champions.
+                ///
+                /// Field | Name | Identifier | Id
+                /// ---|---|---|---
+                /// `NONE` | None (no ban) | | -1
+                #( #[doc = #doc_rows ] )*
+                pub newtype_enum Champion(i16) {
+                    /// `-1`, none. Appears when a champion ban is not used in champ select.
+                    NONE = -1,
+                    #( #variants )*
+                }
+            }
+        }
+    };
+
+    let champion_impl = {
+        let id_cases = champions.iter().map(|champion| {
+            let id = Literal::i16_unsuffixed(champion.id);
+            let ident = Ident::new(&champion.alias.to_shouty_snake_case(), Span::call_site());
+            quote! {
+                Self::#ident => Some(#id),
+            }
+        });
+        let identifier_doc_rows = champions
+            .iter()
+            .filter(|champion| {
+                champion.alias
+                    != champion
+                        .name
+                        .replace(|c| char::is_ascii_alphanumeric(&c), "")
+            })
+            .map(|champion| {
+                let id = champion.id;
+                let name = &champion.name;
+                let alias = &champion.alias;
+                format!("`{}` | {} | {} | {}", id, name, alias, id)
+            });
+        let identifier_cases = champions.iter().map(|champion| {
+            let ident = Ident::new(&champion.alias.to_shouty_snake_case(), Span::call_site());
+            let alias = &champion.alias;
+            quote! {
+                Self::#ident => Some(#alias),
+            }
+        });
+
+        quote! {
+            impl Champion {
+                /// The champion's name (`en_US` localization).
+                pub const fn id(self) -> Option<i16> {
+                    match self {
+                        #( #id_cases )*
+                        _ => None,
+                    }
+                }
+
+                /// The champion's identifier key. Somtimes called "key", "identifier", or "alias".
+                /// This is mainly used in DDragon paths.
+                ///
+                /// This is generally the `en_US` name with spaces and punctuation removed,
+                /// capitalization preserved, however the follow are exceptions:
+                ///
+                /// Field | Name | Identifier | Id
+                /// ---|---|---|---
+                #( #[doc = #identifier_doc_rows] )*
+                pub const fn identifier(self) -> Option<&'static str> {
+                    match self {
+                        #( #identifier_cases )*
+                        _ => None,
+                    }
+                }
+            }
+        }
+    };
+
+    let champion_parse = {
+        let cases: BTreeMap<String, &Champion> = champions
+            .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());
+
+                    IntoIterator::into_iter([
+                        Box::new(chars_full) as Box<dyn Iterator<Item = char>>,
+                        Box::new(chars_first),
+                    ])
+                    .map(move |chars| {
+                        let str: String = chars
+                            .map(|c| c.to_ascii_uppercase())
+                            .chain(std::iter::repeat('\0'))
+                            .take(4)
+                            .collect();
+                        (str, champion)
+                    })
+                })
+            })
+            .collect();
+        let cases = cases.into_iter().map(|(s, champion)| {
+            let ident = Ident::new(&champion.alias.to_shouty_snake_case(), Span::call_site());
+            let chars = s.chars().map(|c| Literal::character(c));
+            quote! {
+                [#( #chars ),*] => Ok(Champion::#ident),
+            }
+        });
+
+        quote! {
+            impl std::str::FromStr for Champion {
+                type Err = ParseChampionError;
+                fn from_str(s: &str) -> Result<Self, Self::Err> {
+                    let mut chars = ['\0'; 4];
+                    s.chars()
+                        .take(4)
+                        .filter(|c| c.is_ascii_alphanumeric())
+                        .map(|c| c.to_ascii_uppercase())
+                        .enumerate()
+                        .for_each(|(i, c)| chars[i] = c);
+                    match chars {
+                        #( #cases )*
+                        unknown => Err(ParseChampionError(unknown)),
+                    }
+                }
+            }
+        }
+    };
+
+    parse_quote! {
+        #newtype_enum
+        #champion_impl
+        #champion_parse
+    }
+}

riven/build/champion.rs

@@ -0,0 +1,16 @@
+use std::iter::FromIterator;
+use std::path::PathBuf;
+use std::{env, fs};
+
+mod champion;
+
+fn main() {
+    println!("cargo:rerun-if-changed=schemas");
+    println!("cargo:rerun-if-changed=build");
+
+    fs::write(
+        PathBuf::from_iter([&env::var("OUT_DIR").unwrap(), "champion.rs"]),
+        prettyplease::unparse(&champion::champion()),
+    )
+    .unwrap();
+}