From 30a94754cd9b65af79336d18b41fd0dc0e9c4710 Mon Sep 17 00:00:00 2001 From: Stefano Pigozzi Date: Sat, 3 Sep 2022 19:15:44 +0200 Subject: [PATCH] Run `cargo fmt` --- src/data/corebundle/keyword.rs | 3 +- src/data/corebundle/rarity.rs | 3 +- src/data/corebundle/set.rs | 3 +- src/data/corebundle/vocabterm.rs | 1 - src/data/deckcode/deck.rs | 203 ++++++++++++++++++++++--------- src/data/deckcode/format.rs | 6 +- src/data/deckcode/mod.rs | 4 +- src/data/deckcode/version.rs | 9 +- src/data/mod.rs | 2 +- src/data/setbundle/card.rs | 26 ++-- src/data/setbundle/code.rs | 20 +-- src/data/setbundle/mod.rs | 2 +- src/data/setbundle/region.rs | 48 ++++---- src/data/setbundle/set.rs | 2 - src/search/cardsearch.rs | 2 +- src/telegram/display.rs | 13 +- src/telegram/handler.rs | 8 +- src/telegram/inline.rs | 26 ++-- src/telegram/main.rs | 6 +- 19 files changed, 232 insertions(+), 155 deletions(-) diff --git a/src/data/corebundle/keyword.rs b/src/data/corebundle/keyword.rs index 157f1e6..390d582 100644 --- a/src/data/corebundle/keyword.rs +++ b/src/data/corebundle/keyword.rs @@ -1,7 +1,7 @@ //! Module defining structs representing localized card keywords. -use std::collections::HashMap; use crate::data::setbundle::keyword::CardKeyword; +use std::collections::HashMap; /// A Legends of Runeterra [CardKeyword], and its associated localization. #[derive(Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] @@ -22,7 +22,6 @@ pub type LocalizedCardKeywordVec = Vec; /// An index of [LocalizedCardKeyword]s, with [LocalizedCardKeyword::keyword]s as keys. pub type LocalizedCardKeywordIndex = HashMap; - #[cfg(test)] mod tests { use super::*; diff --git a/src/data/corebundle/rarity.rs b/src/data/corebundle/rarity.rs index 92996f2..2aa1957 100644 --- a/src/data/corebundle/rarity.rs +++ b/src/data/corebundle/rarity.rs @@ -1,7 +1,7 @@ //! Module defining structs representing localized card rarities. -use std::collections::HashMap; use crate::data::setbundle::rarity::CardRarity; +use std::collections::HashMap; /// A Legends of Runeterra [CardRarity], and its associated localization. #[derive(Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] @@ -19,7 +19,6 @@ pub type LocalizedCardRarityVec = Vec; /// An index of [LocalizedCardRarity]s, with [LocalizedCardRarity::rarity]s as keys. pub type LocalizedCardRarityIndex = HashMap; - #[cfg(test)] mod tests { use super::*; diff --git a/src/data/corebundle/set.rs b/src/data/corebundle/set.rs index 08e9334..b12f140 100644 --- a/src/data/corebundle/set.rs +++ b/src/data/corebundle/set.rs @@ -1,7 +1,7 @@ //! Module defining structs representing localized card sets. -use std::collections::HashMap; use crate::data::setbundle::set::CardSet; +use std::collections::HashMap; /// A Legends of Runeterra [CardSet], and its associated localization. #[derive(Clone, Debug, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)] @@ -23,7 +23,6 @@ pub type LocalizedCardSetVec = Vec; /// An index of [LocalizedCardSet]s, with [LocalizedCardSet::set]s as keys. pub type LocalizedCardSetIndex = HashMap; - #[cfg(test)] mod tests { use super::*; diff --git a/src/data/corebundle/vocabterm.rs b/src/data/corebundle/vocabterm.rs index e8f4066..71443f2 100644 --- a/src/data/corebundle/vocabterm.rs +++ b/src/data/corebundle/vocabterm.rs @@ -24,7 +24,6 @@ pub type LocalizedVocabTermVec = Vec; /// An index of [LocalizedVocabTerm]s, with [LocalizedVocabTerm::vocabterm]s as keys. pub type LocalizedVocabTermIndex = HashMap; - #[cfg(test)] mod tests { use super::*; diff --git a/src/data/deckcode/deck.rs b/src/data/deckcode/deck.rs index b0b1665..ebf445c 100644 --- a/src/data/deckcode/deck.rs +++ b/src/data/deckcode/deck.rs @@ -1,15 +1,14 @@ //! Module defining the [`Deck`] struct and its serialization methods and results. -use std::collections::HashMap; -use std::io::{Cursor, Read, Write}; -use itertools::Itertools; -use varint_rs::{VarintReader, VarintWriter}; +use super::format::DeckCodeFormat; use crate::data::deckcode::version::{DeckCodeVersion, DeckCodeVersioned}; use crate::data::setbundle::code::CardCode; use crate::data::setbundle::region::CardRegion; use crate::data::setbundle::set::CardSet; -use super::format::DeckCodeFormat; - +use itertools::Itertools; +use std::collections::HashMap; +use std::io::{Cursor, Read, Write}; +use varint_rs::{VarintReader, VarintWriter}; /// A unshuffled Legends of Runeterra card deck. #[derive(Clone, Debug, PartialEq, Eq)] @@ -18,7 +17,6 @@ pub struct Deck { pub contents: HashMap, } - impl Deck { /// Decode a deck code into a [`Vec`] of [bytes](u8). fn decode_code(code: &str) -> DeckDecodingResult> { @@ -29,23 +27,32 @@ impl Deck { /// Encode a slice of [bytes](u8) into a deck code. fn encode_code(bytes: &[u8]) -> String { - data_encoding::BASE32_NOPAD - .encode(bytes) + data_encoding::BASE32_NOPAD.encode(bytes) } /// [Read] the header byte into a [format](DeckCodeFormat) and [version](DeckCodeVersion) tuple. - fn read_header(reader: &mut R) -> DeckDecodingResult<(DeckCodeFormat, DeckCodeVersion)> { + fn read_header( + reader: &mut R, + ) -> DeckDecodingResult<(DeckCodeFormat, DeckCodeVersion)> { let mut format_version: [u8; 1] = [0; 1]; - reader.read_exact(&mut format_version).map_err(DeckDecodingError::Read)?; + reader + .read_exact(&mut format_version) + .map_err(DeckDecodingError::Read)?; - let format = DeckCodeFormat::try_from(format_version[0] >> 4).map_err(|_| DeckDecodingError::UnknownFormat)?; - let version = DeckCodeVersion::try_from(format_version[0] & 0xF).map_err(|_| DeckDecodingError::UnknownVersion)?; + let format = DeckCodeFormat::try_from(format_version[0] >> 4) + .map_err(|_| DeckDecodingError::UnknownFormat)?; + let version = DeckCodeVersion::try_from(format_version[0] & 0xF) + .map_err(|_| DeckDecodingError::UnknownVersion)?; Ok((format, version)) } /// [Write] the header byte with the given [format](DeckCodeFormat) and [version](DeckCodeVersion). - fn write_header(writer: &mut W, format: DeckCodeFormat, version: DeckCodeVersion) -> DeckEncodingResult<()> { + fn write_header( + writer: &mut W, + format: DeckCodeFormat, + version: DeckCodeVersion, + ) -> DeckEncodingResult<()> { let format: u8 = format.into(); let version: u8 = version.into(); @@ -103,7 +110,11 @@ impl Deck { } /// [Read] the **groups** of a single supergroup. - fn read_f1_supergroup(reader: &mut R, contents: &mut HashMap, quantity: u32) -> DeckDecodingResult<()> { + fn read_f1_supergroup( + reader: &mut R, + contents: &mut HashMap, + quantity: u32, + ) -> DeckDecodingResult<()> { // Read the number of groups in the supergroup let len = reader.read_u32_varint().map_err(DeckDecodingError::Read)?; @@ -116,7 +127,9 @@ impl Deck { } /// Given a slice of [`CardCode`]s, group them by set and region. - fn f1_group_cards<'cc>(codes: &[&'cc CardCode]) -> HashMap<(&'cc str, &'cc str), Vec<&'cc CardCode>> { + fn f1_group_cards<'cc>( + codes: &[&'cc CardCode], + ) -> HashMap<(&'cc str, &'cc str), Vec<&'cc CardCode>> { // Create the hashmap accumulating groups of cards // It has the tuple (set, region) as key let mut groups = HashMap::new(); @@ -145,22 +158,28 @@ impl Deck { } /// [Write] the **groups** of a single supergroup. - fn write_f1_supergroup(writer: &mut W, supergroup: &[&CardCode]) -> DeckEncodingResult<()> { + fn write_f1_supergroup( + writer: &mut W, + supergroup: &[&CardCode], + ) -> DeckEncodingResult<()> { // Arrange cards into groups let groups = Self::f1_group_cards(supergroup); // Determine the number of groups in the supergroup - let len: u32 = groups.len().try_into().expect("groups length to be smaller than usize"); - writer.write_u32_varint(len).map_err(DeckEncodingError::Write)?; + let len: u32 = groups + .len() + .try_into() + .expect("groups length to be smaller than usize"); + writer + .write_u32_varint(len) + .map_err(DeckEncodingError::Write)?; // Sort first by ascending group length, then by key let groups = groups .into_iter() - .sorted_by(|(a_key, a_group), (b_key, b_group)| - a_group.len().cmp(&b_group.len()) - .then( - a_key.cmp(b_key)) - ); + .sorted_by(|(a_key, a_group), (b_key, b_group)| { + a_group.len().cmp(&b_group.len()).then(a_key.cmp(b_key)) + }); // Write all groups for ((set, region), group) in groups { @@ -171,14 +190,22 @@ impl Deck { } /// [Read] the **cards** of a single group. - fn read_f1_group(reader: &mut R, contents: &mut HashMap, quantity: u32) -> DeckDecodingResult<()> { + fn read_f1_group( + reader: &mut R, + contents: &mut HashMap, + quantity: u32, + ) -> DeckDecodingResult<()> { let card_count = reader.read_u32_varint().map_err(DeckDecodingError::Read)?; let set = reader.read_u32_varint().map_err(DeckDecodingError::Read)?; - let set = CardSet::from(set).to_code().ok_or(DeckDecodingError::UnknownSet)?; + let set = CardSet::from(set) + .to_code() + .ok_or(DeckDecodingError::UnknownSet)?; let region = reader.read_u32_varint().map_err(DeckDecodingError::Read)?; - let region = CardRegion::from(region).to_code().ok_or(DeckDecodingError::UnknownRegion)?; + let region = CardRegion::from(region) + .to_code() + .ok_or(DeckDecodingError::UnknownRegion)?; for _card in 0..card_count { Self::read_f1_standard_card(reader, contents, quantity, &set, ®ion)?; @@ -188,15 +215,33 @@ impl Deck { } /// [Write] the **cards** of a single group. - fn write_f1_group(writer: &mut W, group: &[&CardCode], set: &str, region: &str) -> DeckEncodingResult<()> { - let len: u32 = group.len().try_into().expect("cards length to be smaller than usize"); - writer.write_u32_varint(len).map_err(DeckEncodingError::Write)?; + fn write_f1_group( + writer: &mut W, + group: &[&CardCode], + set: &str, + region: &str, + ) -> DeckEncodingResult<()> { + let len: u32 = group + .len() + .try_into() + .expect("cards length to be smaller than usize"); + writer + .write_u32_varint(len) + .map_err(DeckEncodingError::Write)?; - let set: u32 = CardSet::from_code(set).try_into().map_err(|_| DeckEncodingError::UnknownSet)?; - writer.write_u32_varint(set).map_err(DeckEncodingError::Write)?; + let set: u32 = CardSet::from_code(set) + .try_into() + .map_err(|_| DeckEncodingError::UnknownSet)?; + writer + .write_u32_varint(set) + .map_err(DeckEncodingError::Write)?; - let region: u32 = CardRegion::from_code(region).try_into().map_err(|_| DeckEncodingError::UnknownRegion)?; - writer.write_u32_varint(region).map_err(DeckEncodingError::Write)?; + let region: u32 = CardRegion::from_code(region) + .try_into() + .map_err(|_| DeckEncodingError::UnknownRegion)?; + writer + .write_u32_varint(region) + .map_err(DeckEncodingError::Write)?; for card in group.iter().sorted() { Self::write_f1_standard_card(writer, card.card())?; @@ -206,7 +251,13 @@ impl Deck { } /// [Read] **a single card**. - fn read_f1_standard_card(reader: &mut R, contents: &mut HashMap, quantity: u32, set: &str, region: &str) -> DeckDecodingResult<()> { + fn read_f1_standard_card( + reader: &mut R, + contents: &mut HashMap, + quantity: u32, + set: &str, + region: &str, + ) -> DeckDecodingResult<()> { let card = reader.read_u32_varint().map_err(DeckDecodingError::Read)?; let code = CardCode::from_s_r_c(set, region, card); @@ -217,15 +268,21 @@ impl Deck { /// [Write] **a single card**. fn write_f1_standard_card(writer: &mut W, card: &str) -> DeckEncodingResult<()> { - let card = card.parse::().map_err(DeckEncodingError::InvalidCardNumber)?; - writer.write_u32_varint(card).map_err(DeckEncodingError::Write)?; + let card = card + .parse::() + .map_err(DeckEncodingError::InvalidCardNumber)?; + writer + .write_u32_varint(card) + .map_err(DeckEncodingError::Write)?; Ok(()) } /// [Read] the **extra segment** of the deck code. - fn read_f1_extra(reader: &mut R, contents: &mut HashMap) -> DeckDecodingResult<()> { - + fn read_f1_extra( + reader: &mut R, + contents: &mut HashMap, + ) -> DeckDecodingResult<()> { // While the cursor has still some bytes left... while Self::read_f1_extra_card(reader, contents).is_ok() {} @@ -233,7 +290,10 @@ impl Deck { } /// [Write] the **extra segment** of the deck code. - fn write_f1_extra(writer: &mut W, codes: Vec<(&CardCode, u32)>) -> DeckEncodingResult<()> { + fn write_f1_extra( + writer: &mut W, + codes: Vec<(&CardCode, u32)>, + ) -> DeckEncodingResult<()> { for (code, quantity) in codes.iter().sorted() { Self::write_f1_extra_card(writer, code, *quantity)?; } @@ -242,14 +302,21 @@ impl Deck { } /// [Read] **a single card** with a **non-standard quantity**. - fn read_f1_extra_card(reader: &mut R, contents: &mut HashMap) -> DeckDecodingResult<()> { + fn read_f1_extra_card( + reader: &mut R, + contents: &mut HashMap, + ) -> DeckDecodingResult<()> { let quantity = reader.read_u32_varint().map_err(DeckDecodingError::Read)?; let set = reader.read_u32_varint().map_err(DeckDecodingError::Read)?; - let set = CardSet::from(set).to_code().ok_or(DeckDecodingError::UnknownSet)?; + let set = CardSet::from(set) + .to_code() + .ok_or(DeckDecodingError::UnknownSet)?; let region = reader.read_u32_varint().map_err(DeckDecodingError::Read)?; - let region = CardRegion::from(region).to_code().ok_or(DeckDecodingError::UnknownRegion)?; + let region = CardRegion::from(region) + .to_code() + .ok_or(DeckDecodingError::UnknownRegion)?; let card = reader.read_u32_varint().map_err(DeckDecodingError::Read)?; @@ -260,19 +327,36 @@ impl Deck { } /// [Write] **a single card** with a **non-standard quantity**. - fn write_f1_extra_card(writer: &mut W, code: &CardCode, quantity: u32) -> DeckEncodingResult<()> { - writer.write_u32_varint(quantity).map_err(DeckEncodingError::Write)?; + fn write_f1_extra_card( + writer: &mut W, + code: &CardCode, + quantity: u32, + ) -> DeckEncodingResult<()> { + writer + .write_u32_varint(quantity) + .map_err(DeckEncodingError::Write)?; let set = CardSet::from_code(code.set()); let set: u32 = set.try_into().map_err(|_| DeckEncodingError::UnknownSet)?; - writer.write_u32_varint(set).map_err(DeckEncodingError::Write)?; + writer + .write_u32_varint(set) + .map_err(DeckEncodingError::Write)?; let region = CardRegion::from_code(code.region()); - let region: u32 = region.try_into().map_err(|_| DeckEncodingError::UnknownRegion)?; - writer.write_u32_varint(region).map_err(DeckEncodingError::Write)?; + let region: u32 = region + .try_into() + .map_err(|_| DeckEncodingError::UnknownRegion)?; + writer + .write_u32_varint(region) + .map_err(DeckEncodingError::Write)?; - let card = code.card().parse::().map_err(DeckEncodingError::InvalidCardNumber)?; - writer.write_u32_varint(card).map_err(DeckEncodingError::Write)?; + let card = code + .card() + .parse::() + .map_err(DeckEncodingError::InvalidCardNumber)?; + writer + .write_u32_varint(card) + .map_err(DeckEncodingError::Write)?; Ok(()) } @@ -293,7 +377,7 @@ impl Deck { let (format, _version) = Self::read_header(&mut cursor)?; match format { - DeckCodeFormat::F1 => Self::read_f1_body(&mut cursor) + DeckCodeFormat::F1 => Self::read_f1_body(&mut cursor), } } @@ -315,7 +399,9 @@ impl Deck { pub fn to_code(&self, format: DeckCodeFormat) -> DeckEncodingResult { let mut cursor = Cursor::new(Vec::new()); - let version = self.min_deckcode_version().ok_or(DeckEncodingError::UnknownVersion)?; + let version = self + .min_deckcode_version() + .ok_or(DeckEncodingError::UnknownVersion)?; Self::write_header(&mut cursor, format, version)?; @@ -327,7 +413,6 @@ impl Deck { } } - /// An error occoured while decoding a [`Deck`] from a code. #[derive(Debug)] pub enum DeckDecodingError { @@ -366,7 +451,6 @@ pub type DeckDecodingResult = Result; /// The [`Result`] of a [`Deck`] **encoding** operation, for example [`Deck::to_code`]. pub type DeckEncodingResult = Result; - /// Macro to build a deck from card code strings and quantities. /// /// # Example @@ -408,7 +492,7 @@ macro_rules! deck { } } - +#[rustfmt::skip::macros(test_de_ser, test_ser_de)] #[cfg(test)] mod tests { use super::*; @@ -457,12 +541,14 @@ mod tests { fn $id() { use patched_porobot::data::deckcode::deck::Deck; let deck1 = $deck; - let code = deck1.to_code(DeckCodeFormat::F1).expect("deck to serialize successfully"); + let code = deck1 + .to_code(DeckCodeFormat::F1) + .expect("deck to serialize successfully"); println!("Serialized deck code (for science, obviously): {}", &code); let deck2 = Deck::from_code(&code).expect("deck to deserialize successfully"); assert_eq!(deck1, deck2); } - } + }; } // Some tests from https://github.com/RiotGames/LoRDeckCodes/blob/main/LoRDeckCodes_Tests/UnitTest1.cs @@ -571,5 +657,4 @@ mod tests { ]); //test_ser_de!(test_ser_de_, deck![]); - -} \ No newline at end of file +} diff --git a/src/data/deckcode/format.rs b/src/data/deckcode/format.rs index ba2853f..af55731 100644 --- a/src/data/deckcode/format.rs +++ b/src/data/deckcode/format.rs @@ -1,6 +1,5 @@ //! Module defining [`DeckCodeFormat`]. - /// The format of a deck code. #[non_exhaustive] #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -9,14 +8,13 @@ pub enum DeckCodeFormat { F1, } - impl TryFrom for DeckCodeFormat { type Error = (); fn try_from(value: u8) -> Result { match value { 1 => Ok(Self::F1), - _ => Err(()) + _ => Err(()), } } } @@ -27,4 +25,4 @@ impl From for u8 { DeckCodeFormat::F1 => 1, } } -} \ No newline at end of file +} diff --git a/src/data/deckcode/mod.rs b/src/data/deckcode/mod.rs index 472a994..c7586f3 100644 --- a/src/data/deckcode/mod.rs +++ b/src/data/deckcode/mod.rs @@ -1,7 +1,7 @@ //! Module defining the types used to deserialize deck codes. -//! +//! //! Adapted from [RiotGames/LoRDeckCodes](https://github.com/RiotGames/LoRDeckCodes) and from [iulianR/lordeckcodes-rs](https://github.com/iulianR/lordeckcodes-rs). pub mod deck; -pub mod version; pub mod format; +pub mod version; diff --git a/src/data/deckcode/version.rs b/src/data/deckcode/version.rs index 50b5297..216721a 100644 --- a/src/data/deckcode/version.rs +++ b/src/data/deckcode/version.rs @@ -4,7 +4,6 @@ use crate::data::deckcode::deck::Deck; use crate::data::setbundle::code::CardCode; use crate::data::setbundle::region::CardRegion; - /// The version of a deck code. #[non_exhaustive] #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] @@ -27,7 +26,6 @@ pub enum DeckCodeVersion { V5, } - impl TryFrom for DeckCodeVersion { type Error = (); @@ -38,7 +36,7 @@ impl TryFrom for DeckCodeVersion { 3 => Ok(Self::V3), 4 => Ok(Self::V4), 5 => Ok(Self::V5), - _ => Err(()) + _ => Err(()), } } } @@ -55,15 +53,12 @@ impl From for u8 { } } - - /// Indicates that a given type is versioned in the [specs for deck codes](https://github.com/RiotGames/LoRDeckCodes). pub trait DeckCodeVersioned { /// Get the minimum deck version required to encode the deck in "code" format. fn min_deckcode_version(&self) -> Option; } - impl DeckCodeVersioned for CardRegion { fn min_deckcode_version(&self) -> Option { match self { @@ -91,7 +86,6 @@ impl DeckCodeVersioned for CardRegion { } } - /// [`CardCode`]'s version is the maximum version of its components. impl DeckCodeVersioned for CardCode { fn min_deckcode_version(&self) -> Option { @@ -99,7 +93,6 @@ impl DeckCodeVersioned for CardCode { } } - /// [`Deck`]'s version is the maximum version of all its [`CardCode`]s. impl DeckCodeVersioned for Deck { fn min_deckcode_version(&self) -> Option { diff --git a/src/data/mod.rs b/src/data/mod.rs index 83ba196..7af9b00 100644 --- a/src/data/mod.rs +++ b/src/data/mod.rs @@ -4,5 +4,5 @@ pub mod anybundle; pub mod corebundle; -pub mod setbundle; pub mod deckcode; +pub mod setbundle; diff --git a/src/data/setbundle/card.rs b/src/data/setbundle/card.rs index 5289fea..2ee77f8 100644 --- a/src/data/setbundle/card.rs +++ b/src/data/setbundle/card.rs @@ -1,17 +1,17 @@ //! Module defining [Card]. -use std::collections::HashMap; -use std::hash::{Hash, Hasher}; -use crate::data::setbundle::subtype::CardSubtype; -use crate::data::setbundle::supertype::CardSupertype; -use super::r#type::CardType; use super::art::CardArt; +use super::code::CardCode; use super::keyword::CardKeyword; +use super::r#type::CardType; use super::rarity::CardRarity; use super::region::CardRegion; -use super::speed::SpellSpeed; use super::set::CardSet; -use super::code::CardCode; +use super::speed::SpellSpeed; +use crate::data::setbundle::subtype::CardSubtype; +use crate::data::setbundle::supertype::CardSupertype; +use std::collections::HashMap; +use std::hash::{Hash, Hasher}; /// A single Legends of Runeterra card, as represented in a `set*.json` file. /// @@ -146,10 +146,12 @@ pub struct Card { pub supertype: CardSupertype, } - impl Card { /// Get references to the cards associated with this one, given an [HashMap] of cards indexed by code. - pub fn associated_cards<'c, 'hm: 'c>(&'c self, index: &'hm CardIndex) -> impl Iterator> + 'c { + pub fn associated_cards<'c, 'hm: 'c>( + &'c self, + index: &'hm CardIndex, + ) -> impl Iterator> + 'c { self.associated_card_codes.iter().map(|r| index.get(r)) } @@ -161,7 +163,6 @@ impl Card { } } - /// Two [`Card`]s are equal if they have the same [`Card::code`]. impl PartialEq for Card { fn eq(&self, other: &Self) -> bool { @@ -169,7 +170,6 @@ impl PartialEq for Card { } } - /// [`Card`] [`Hash`]es are equal to hashes of their [`Card::code`]. impl Hash for Card { fn hash(&self, state: &mut H) { @@ -177,11 +177,9 @@ impl Hash for Card { } } - /// An index of [Card]s, with [CardCode]s as keys. pub type CardIndex = HashMap; - #[cfg(test)] mod tests { use super::*; @@ -277,4 +275,4 @@ mod tests { } ) } -} \ No newline at end of file +} diff --git a/src/data/setbundle/code.rs b/src/data/setbundle/code.rs index 7e6e628..26a11bb 100644 --- a/src/data/setbundle/code.rs +++ b/src/data/setbundle/code.rs @@ -1,10 +1,9 @@ //! Module defining [CardCode]. - use crate::data::setbundle::card::{Card, CardIndex}; /// The internal code of a [Card](super::card::Card). -/// +/// /// It is a ASCII string composed of the following segments: /// - `0..2`: set; /// - `2..4`: region; @@ -22,17 +21,18 @@ use crate::data::setbundle::card::{Card, CardIndex}; /// # Warning /// /// The way this is built is pretty... unsafe, so beware to not construct this with invalid codes. -#[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize)] +#[derive( + Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize, +)] #[serde(transparent)] pub struct CardCode { /// The card code as a [`String`]. - pub full: String + pub full: String, } - impl CardCode { /// Determines whether the card code is valid or not by checking the following: - /// + /// /// - that the full string [is ascii](str::is_ascii); /// - that it is either 7 or 9 characters long. pub fn is_valid(&self) -> bool { @@ -44,28 +44,28 @@ impl CardCode { } /// The set segment of the code. - /// + /// /// In valid codes, it is always 2-ASCII-characters long. pub fn set(&self) -> &str { &self.full[0..2] } /// The region segment of the code. - /// + /// /// In valid codes, it is always 2-ASCII-characters long. pub fn region(&self) -> &str { &self.full[2..4] } /// The card segment of the code. - /// + /// /// In valid codes, it is always 3-ASCII-characters long. pub fn card(&self) -> &str { &self.full[4..7] } /// The token segment of the code. - /// + /// /// In valid codes, it may either be an empty string, or 2-ASCII-characters long. pub fn token(&self) -> &str { &self.full[7..9] diff --git a/src/data/setbundle/mod.rs b/src/data/setbundle/mod.rs index ac6b5b6..2785076 100644 --- a/src/data/setbundle/mod.rs +++ b/src/data/setbundle/mod.rs @@ -10,6 +10,7 @@ use std::path::Path; pub mod art; pub mod card; +pub mod code; pub mod keyword; pub mod rarity; pub mod region; @@ -18,7 +19,6 @@ pub mod speed; pub mod subtype; pub mod supertype; pub mod r#type; -pub mod code; /// A parsed [Data Dragon] [Set Bundle]. /// diff --git a/src/data/setbundle/region.rs b/src/data/setbundle/region.rs index 8c69ded..f2fb1c4 100644 --- a/src/data/setbundle/region.rs +++ b/src/data/setbundle/region.rs @@ -50,7 +50,10 @@ impl CardRegion { /// Returns [Option::None] if no matching [LocalizedCardRegion] was found, for example for [CardRegion::Unsupported] regions. /// /// Equivalent to calling [LocalizedCardRegionIndex::get]. - pub fn localized<'hm>(&self, hm: &'hm LocalizedCardRegionIndex) -> Option<&'hm LocalizedCardRegion> { + pub fn localized<'hm>( + &self, + hm: &'hm LocalizedCardRegionIndex, + ) -> Option<&'hm LocalizedCardRegion> { hm.get(self) } @@ -101,18 +104,18 @@ impl CardRegion { impl From for CardRegion { fn from(value: u32) -> Self { match value { - 0 => CardRegion::Demacia, - 1 => CardRegion::Freljord, - 2 => CardRegion::Ionia, - 3 => CardRegion::Noxus, - 4 => CardRegion::PiltoverZaun, - 5 => CardRegion::ShadowIsles, - 6 => CardRegion::Bilgewater, - 7 => CardRegion::Shurima, - 9 => CardRegion::Targon, + 0 => CardRegion::Demacia, + 1 => CardRegion::Freljord, + 2 => CardRegion::Ionia, + 3 => CardRegion::Noxus, + 4 => CardRegion::PiltoverZaun, + 5 => CardRegion::ShadowIsles, + 6 => CardRegion::Bilgewater, + 7 => CardRegion::Shurima, + 9 => CardRegion::Targon, 10 => CardRegion::BandleCity, 12 => CardRegion::Runeterra, - _ => CardRegion::Unsupported, + _ => CardRegion::Unsupported, } } } @@ -125,23 +128,22 @@ impl TryFrom for u32 { fn try_from(value: CardRegion) -> Result { match value { - CardRegion::Demacia => Ok(0), - CardRegion::Freljord => Ok(1), - CardRegion::Ionia => Ok(2), - CardRegion::Noxus => Ok(3), + CardRegion::Demacia => Ok(0), + CardRegion::Freljord => Ok(1), + CardRegion::Ionia => Ok(2), + CardRegion::Noxus => Ok(3), CardRegion::PiltoverZaun => Ok(4), - CardRegion::ShadowIsles => Ok(5), - CardRegion::Bilgewater => Ok(6), - CardRegion::Shurima => Ok(7), - CardRegion::Targon => Ok(9), - CardRegion::BandleCity => Ok(10), - CardRegion::Runeterra => Ok(12), - _ => Err(()), + CardRegion::ShadowIsles => Ok(5), + CardRegion::Bilgewater => Ok(6), + CardRegion::Shurima => Ok(7), + CardRegion::Targon => Ok(9), + CardRegion::BandleCity => Ok(10), + CardRegion::Runeterra => Ok(12), + _ => Err(()), } } } - #[cfg(test)] #[rustfmt::skip] mod tests { diff --git a/src/data/setbundle/set.rs b/src/data/setbundle/set.rs index 2873391..1700aad 100644 --- a/src/data/setbundle/set.rs +++ b/src/data/setbundle/set.rs @@ -86,7 +86,6 @@ impl CardSet { } } - /// Get the [`CardSet`] from its internal id. /// /// [`CardSet::Events`] cards have the id of the set they were released in, so it is impossible to determine if a card belongs to that set from its id. @@ -123,7 +122,6 @@ impl TryFrom for u32 { } } - #[cfg(test)] mod tests { use super::CardSet; diff --git a/src/search/cardsearch.rs b/src/search/cardsearch.rs index 1da051b..a2f54cd 100644 --- a/src/search/cardsearch.rs +++ b/src/search/cardsearch.rs @@ -2,13 +2,13 @@ use crate::data::corebundle::globals::LocalizedGlobalsIndexes; use crate::data::setbundle::card::{Card, CardIndex}; +use crate::data::setbundle::code::CardCode; use itertools::Itertools; use tantivy::collector::TopDocs; use tantivy::query::{QueryParser, QueryParserError}; use tantivy::schema::{Field, NumericOptions, Schema, TextOptions}; use tantivy::tokenizer::TextAnalyzer; use tantivy::{Document, Index, IndexReader, IndexWriter}; -use crate::data::setbundle::code::CardCode; /// The search engine. /// diff --git a/src/telegram/display.rs b/src/telegram/display.rs index 4d8a9d5..d53170a 100644 --- a/src/telegram/display.rs +++ b/src/telegram/display.rs @@ -6,6 +6,7 @@ use crate::data::corebundle::globals::LocalizedGlobalsIndexes; use crate::data::corebundle::keyword::LocalizedCardKeywordIndex; use crate::data::corebundle::region::LocalizedCardRegionIndex; use crate::data::corebundle::set::LocalizedCardSetIndex; +use crate::data::deckcode::deck::Deck; use crate::data::setbundle::card::{Card, CardIndex}; use crate::data::setbundle::keyword::CardKeyword; use crate::data::setbundle::r#type::CardType; @@ -13,7 +14,6 @@ use crate::data::setbundle::region::CardRegion; use crate::data::setbundle::set::CardSet; use crate::data::setbundle::subtype::CardSubtype; use crate::data::setbundle::supertype::CardSupertype; -use crate::data::deckcode::deck::Deck; use itertools::Itertools; use teloxide::utils::html::escape; @@ -158,13 +158,17 @@ fn display_levelup(levelup: &String) -> String { /// [Telegram Bot HTML]: https://core.telegram.org/bots/api#html-style pub fn display_deck(index: &CardIndex, deck: &Deck, code: String) -> String { // TODO: optimize this - let cards = deck.contents + let cards = deck + .contents .keys() .sorted_by(|a, b| { let card_a = index.get(a).expect("card to exist in the index"); let card_b = index.get(b).expect("card to exist in the index"); - card_a.cost.cmp(&card_b.cost).then(card_a.name.cmp(&card_b.name)) + card_a + .cost + .cmp(&card_b.cost) + .then(card_a.name.cmp(&card_b.name)) }) .map(|k| { let card = index.get(k).expect("card to exist in the index"); @@ -172,8 +176,7 @@ pub fn display_deck(index: &CardIndex, deck: &Deck, code: String) -> String { if card.supertype == "Champion" { format!("{}× {}", &quantity, &card.name) - } - else { + } else { format!("{}× {}", &quantity, &card.name) } }) diff --git a/src/telegram/handler.rs b/src/telegram/handler.rs index f772b45..c2fff99 100644 --- a/src/telegram/handler.rs +++ b/src/telegram/handler.rs @@ -1,5 +1,6 @@ //! Module providing handlers for @patchedporobot on Telegram. +use crate::data::deckcode::deck::Deck; use crate::search::cardsearch::CardSearchEngine; use crate::telegram::inline::{card_to_inlinequeryresult, deck_to_inlinequeryresult}; use itertools::Itertools; @@ -9,7 +10,6 @@ use teloxide::payloads::{AnswerInlineQuery, SendMessage}; use teloxide::prelude::*; use teloxide::requests::{JsonRequest, ResponseResult}; use teloxide::types::{ParseMode, Recipient}; -use crate::data::deckcode::deck::Deck; /// Handle inline queries by searching cards on the [CardSearchEngine]. pub fn inline_query_handler( @@ -37,15 +37,13 @@ pub fn inline_query_handler( debug!("Parsed deck successfully!"); break AnswerInlineQuery { inline_query_id: query.id.clone(), - results: vec![ - deck_to_inlinequeryresult(&engine.cards, &deck) - ], + results: vec![deck_to_inlinequeryresult(&engine.cards, &deck)], cache_time: None, is_personal: Some(false), next_offset: None, switch_pm_text: None, switch_pm_parameter: None, - } + }; } debug!("Querying the card search engine..."); diff --git a/src/telegram/inline.rs b/src/telegram/inline.rs index 1e104b1..411e5a9 100644 --- a/src/telegram/inline.rs +++ b/src/telegram/inline.rs @@ -2,15 +2,18 @@ //! //! [inline mode]: https://core.telegram.org/bots/api#inline-mode +use crate::data::corebundle::globals::LocalizedGlobalsIndexes; +use crate::data::deckcode::deck::Deck; +use crate::data::deckcode::format::DeckCodeFormat; +use crate::data::setbundle::card::{Card, CardIndex}; +use crate::telegram::display::{display_card, display_deck}; use std::collections::hash_map::DefaultHasher; use std::hash::Hash; use std::ptr::hash; -use crate::data::corebundle::globals::LocalizedGlobalsIndexes; -use crate::data::setbundle::card::{Card, CardIndex}; -use crate::telegram::display::{display_card, display_deck}; -use teloxide::types::{InlineQueryResult, InlineQueryResultArticle, InlineQueryResultPhoto, InputMessageContent, InputMessageContentText, ParseMode}; -use crate::data::deckcode::deck::Deck; -use crate::data::deckcode::format::DeckCodeFormat; +use teloxide::types::{ + InlineQueryResult, InlineQueryResultArticle, InlineQueryResultPhoto, InputMessageContent, + InputMessageContentText, ParseMode, +}; /// Converts a [Card] into a [InlineQueryResult]. pub fn card_to_inlinequeryresult( @@ -43,9 +46,10 @@ pub fn card_to_inlinequeryresult( }) } - pub fn deck_to_inlinequeryresult(index: &CardIndex, deck: &Deck) -> InlineQueryResult { - let code = deck.to_code(DeckCodeFormat::F1).expect("serialized deck to deserialize properly"); + let code = deck + .to_code(DeckCodeFormat::F1) + .expect("serialized deck to deserialize properly"); InlineQueryResult::Article(InlineQueryResultArticle { id: format!("{:x}", md5::compute(&code)), @@ -54,7 +58,7 @@ pub fn deck_to_inlinequeryresult(index: &CardIndex, deck: &Deck) -> InlineQueryR message_text: display_deck(index, deck, code), parse_mode: Some(ParseMode::Html), entities: None, - disable_web_page_preview: Some(true) + disable_web_page_preview: Some(true), }), reply_markup: None, url: None, @@ -62,6 +66,6 @@ pub fn deck_to_inlinequeryresult(index: &CardIndex, deck: &Deck) -> InlineQueryR description: None, thumb_url: None, thumb_width: None, - thumb_height: None + thumb_height: None, }) -} \ No newline at end of file +} diff --git a/src/telegram/main.rs b/src/telegram/main.rs index 2deb451..91cad16 100644 --- a/src/telegram/main.rs +++ b/src/telegram/main.rs @@ -30,8 +30,10 @@ pub async fn main() { let mut cards: Vec = vec![]; for setpath in setpaths { debug!("Loading {:?}...", &setpath); - let set = SetBundle::load(&setpath) - .expect(&*format!("to be able to load {:?} as a set bundle", &setpath)); + let set = SetBundle::load(&setpath).expect(&*format!( + "to be able to load {:?} as a set bundle", + &setpath + )); let mut setcards = set.cards; cards.append(&mut setcards); }