added key to sort by card amount per set

Author: Daniel Gusenburger

scrollrack-cli/src/main.rs

@@ -2,7 +2,10 @@ use clap::ArgEnum;
 use clap::Parser;
 
 use scrollrack_core::card_query::CardQuery;
-use scrollrack_core::output;
+use scrollrack_core::output::{
+    gen_outfile_name, render, write_to_file, OutputFormat, OutputItemList, OutputTable,
+    SortByCardAmount, SortByDate, SortByName,
+};
 use scrollrack_core::parse;
 
 use anyhow::Result;
@@ -11,6 +14,7 @@ use anyhow::Result;
 enum Ordering {
     ALPHA,
     DATE,
+    AMOUNT,
 }
 
 #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ArgEnum, Debug)]
@@ -38,8 +42,6 @@ struct Args {
 async fn main() -> Result<()> {
     let args = Args::parse();
 
-    println!("{:?}", args);
-
     let lines = parse::read_lines(&args.path)?;
 
     let cards_by_set = CardQuery::default()
@@ -48,23 +50,19 @@ async fn main() -> Result<()> {
 
     let outfile = match args.output {
         Some(path) => path,
-        None => output::gen_outfile_name(&args.path),
+        None => gen_outfile_name(&args.path),
     };
 
     let out_string = match (args.format, args.ordering) {
-        (Output::LIST, Ordering::ALPHA) => {
-            output::render::<output::OutputItemList, output::SortByName>(cards_by_set)
-        }
-        (Output::LIST, Ordering::DATE) => {
-            output::render::<output::OutputItemList, output::SortByDate>(cards_by_set)
-        }
-        (Output::TABLE, Ordering::ALPHA) => {
-            output::render::<output::OutputTable, output::SortByName>(cards_by_set)
-        }
-        (Output::TABLE, Ordering::DATE) => {
-            output::render::<output::OutputTable, output::SortByDate>(cards_by_set)
+        (Output::LIST, Ordering::ALPHA) => render::<OutputItemList, SortByName>(&cards_by_set),
+        (Output::LIST, Ordering::DATE) => render::<OutputItemList, SortByDate>(&cards_by_set),
+        (Output::LIST, Ordering::AMOUNT) => {
+            OutputItemList::render::<SortByCardAmount>(&cards_by_set)
         }
+        (Output::TABLE, Ordering::ALPHA) => render::<OutputTable, SortByName>(&cards_by_set),
+        (Output::TABLE, Ordering::DATE) => render::<OutputTable, SortByDate>(&cards_by_set),
+        (Output::TABLE, Ordering::AMOUNT) => render::<OutputTable, SortByCardAmount>(&cards_by_set),
     };
 
-    output::write_to_file(&out_string, &outfile)
+    write_to_file(&out_string, &outfile)
 }

scrollrack-core/src/output.rs

@@ -16,15 +16,29 @@ pub fn gen_outfile_name(in_name: &str) -> String {
     )
 }
 
+pub fn render<F, P>(cards_by_set: &CardsBySet) -> String
+where
+    F: OutputFormat,
+    P: SetInfoOrder,
+{
+    F::render::<P>(cards_by_set)
+}
+
 pub trait SetInfoOrder {
     type ReturnType: Ord;
     fn get_key(set_info: &SetInfo) -> Self::ReturnType;
+    fn get_combined_key(
+        set_info: &SetInfo,
+        cards_in_set: &Vec<ScryfallCardWrapper>,
+    ) -> Self::ReturnType {
+        Self::get_key(set_info)
+    }
 }
 
 pub struct SortByName;
 impl SetInfoOrder for SortByName {
     type ReturnType = String;
-    fn get_key(set_info: &SetInfo) -> String {
+    fn get_key(set_info: &SetInfo) -> Self::ReturnType {
         set_info.set_name().to_string()
     }
 }
@@ -33,7 +47,7 @@ pub struct SortByDate;
 impl SetInfoOrder for SortByDate {
     type ReturnType = NaiveDate;
     // TODO: Cache set infos ?
-    fn get_key(_set_info: &SetInfo) -> NaiveDate {
+    fn get_key(_set_info: &SetInfo) -> Self::ReturnType {
         // set_info
         //     .set_uri()
         //     .fetch()
@@ -45,36 +59,51 @@ impl SetInfoOrder for SortByDate {
     }
 }
 
-pub trait OutputFormat {
-    fn render<P>(c: CardsBySet) -> String
-    where
-        P: SetInfoOrder;
+pub struct SortByCardAmount;
+impl SetInfoOrder for SortByCardAmount {
+    type ReturnType = i32;
+
+    fn get_key(set_info: &SetInfo) -> Self::ReturnType {
+        panic!("To use SortByCardAmount as a key, use get_combined_key instead.")
+    }
+
+    fn get_combined_key(
+        set_info: &SetInfo,
+        cards_in_set: &Vec<ScryfallCardWrapper>,
+    ) -> Self::ReturnType {
+        -(cards_in_set.len() as i32)
+    }
 }
 
-pub struct OutputItemList;
-impl OutputFormat for OutputItemList {
-    fn render<P>(c: CardsBySet) -> String
+pub trait OutputFormat {
+    fn render<P>(c: &CardsBySet) -> String
     where
         P: SetInfoOrder,
     {
         c.keys()
-            .sorted_by_key(|set_info| P::get_key(set_info))
-            .map(|k| {
-                format!(
-                    "{}:\n{}",
-                    k.set_name(),
-                    c[k].iter()
-                        .sorted_by_key(|card| card.card_name())
-                        .map(|card| if k.virtual_set() {
-                            "\t - ".to_owned() + card.card_name()
-                        } else {
-                            "\t - ".to_owned() + &card.format_detailed()
-                        })
-                        .join("\n")
-                )
-            })
+            .sorted_by_key(|set_info| P::get_combined_key(set_info, &c[set_info]))
+            .map(|k| format!("{}:\n{}", k.set_name(), Self::render_set(k, &c[k])))
             .join("\n\n")
     }
+
+    fn render_set(set_info: &SetInfo, cards: &Vec<ScryfallCardWrapper>) -> String;
+}
+
+pub struct OutputItemList;
+impl OutputFormat for OutputItemList {
+    fn render_set(set_info: &SetInfo, cards: &Vec<ScryfallCardWrapper>) -> String {
+        cards
+            .iter()
+            .sorted_by_key(|card| card.card_name())
+            .map(|card| {
+                if set_info.virtual_set() {
+                    "\t - ".to_owned() + card.card_name()
+                } else {
+                    "\t - ".to_owned() + &card.format_detailed()
+                }
+            })
+            .join("\n")
+    }
 }
 
 #[derive(tabled::Tabled)]
@@ -96,31 +125,17 @@ impl From<&ScryfallCardWrapper> for RenameLater {
 
 pub struct OutputTable;
 impl OutputFormat for OutputTable {
-    fn render<P>(c: CardsBySet) -> String
-    where
-        P: SetInfoOrder,
-    {
-        c.keys()
-            .sorted_by_key(|set_info| P::get_key(set_info))
-            .map(|k| {
-                format!(
-                    "{}:\n{}",
-                    k.set_name(),
-                    Table::new(
-                        c[k].iter()
-                            .sorted_by_key(|card| card.card_name())
-                            .map(|c| Into::<RenameLater>::into(c))
-                    )
-                )
-            })
-            .join("\n\n")
+    fn render_set(_: &SetInfo, cards: &Vec<ScryfallCardWrapper>) -> String {
+        Table::new(
+            cards
+                .iter()
+                .sorted_by_key(|card| card.card_name())
+                .map(|c| Into::<RenameLater>::into(c)),
+        )
+        .to_string()
     }
 }
 
-pub fn render<F: OutputFormat, P: SetInfoOrder>(c: CardsBySet) -> String {
-    F::render::<P>(c)
-}
-
 pub fn write_to_file(data: &str, path: &str) -> Result<()> {
     let mut outfile = File::create(path)?;
     Ok(outfile.write_all(data.as_bytes())?)

scrollrack-core/src/rules/postprocess.rs

@@ -45,6 +45,8 @@ impl Combine {
                 .extend(cards.to_vec().into_iter());
         }
 
+        // TODO: Aggregate card prices to average over each occurrence in the combined sets
+
         for (key, value) in cards_by_set.iter() {
             if !sets_to_combine.contains(&key) {
                 combined