Worked on parsing

src/dance_info.rs

@@ -45,14 +45,14 @@ impl TryFrom<&str> for DanceRole {
     }
 }
 
-#[derive(serde::Deserialize, Debug, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(serde::Deserialize, Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy)]
 pub enum DanceRank {
     Newcomer,
     Novice,
     Intermediate,
     #[serde(rename = "Advance")]
     Advanced,
-    #[serde(rename = "All Star")]
+    #[serde(rename = "All Star", alias = "All-Stars")]
     AllStars,
     Champions,
 }
@@ -70,33 +70,6 @@ impl DanceRank {
     }
 }
 
-#[derive(Debug)]
-pub struct ParseDanceRankError;
-
-impl fmt::Display for ParseDanceRankError {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "failed to parse DanceRank")
-    }
-}
-
-impl std::error::Error for ParseDanceRankError {}
-
-impl std::str::FromStr for DanceRank {
-    type Err = ParseDanceRankError;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "Newcomer" => Ok(Self::Newcomer),
-            "Novice" => Ok(Self::Novice),
-            "Intermediate" => Ok(Self::Intermediate),
-            "Advanced" => Ok(Self::Advanced),
-            "All-Stars" => Ok(Self::AllStars),
-            "Champions" => Ok(Self::Champions),
-            _ => Err(ParseDanceRankError),
-        }
-    }
-}
-
 #[derive(Debug)]
 pub struct CompState {
     pub rank: DanceRank,

src/worldsdc/scoringdance.rs

@@ -61,12 +61,12 @@ fn parse_stats(d: &[Vec<String>]) {
         (a, b)
     });
 
-    let (all_time, rest) = chapters.partition::<Vec<_>, _>(|(a, b)| a.to_lowercase() == "all time");
+    let (all_time, rest) = chapters.partition::<Vec<_>, _>(|(a, _)| a.to_lowercase() == "all time");
     let all_time = &all_time.split_first().unwrap().0.1;
-    let sorted_chapters = rest
+    let mut sorted_chapters = rest
         .into_iter()
         .map(|(chapter, items)| {
-            let rank = DanceRank::from_str(chapter).map_err(|_| chapter.to_owned())?;
+            let rank: DanceRank = serde_json::from_str(chapter).map_err(|_| chapter.to_owned())?;
             Ok::<(DanceRank, Vec<[&String; 2]>), String>((rank, items))
         })
         .filter_map(|v| match v {
@@ -77,7 +77,27 @@ fn parse_stats(d: &[Vec<String>]) {
             }
         })
         .collect::<Vec<_>>();
-    dbg!(&sorted_chapters);
+    sorted_chapters.sort_by_key(|(a, _)| *a);
+    sorted_chapters.reverse();
+    let leader_rank = sorted_chapters.iter().find_map(|(rank, items)| {
+        items
+            .iter()
+            .find(|[a, _]| a.to_lowercase().contains("points leader"))
+            .map(|[_, points]| (rank, points))
+    });
+    let follower_rank = sorted_chapters.iter().find_map(|(rank, items)| {
+        items
+            .iter()
+            .find(|[a, _]| a.to_lowercase().contains("points follower"))
+            .map(|[_, points]| (rank, points))
+    });
+    let primary_role = all_time.iter().find_map(|[key, value]| {
+        if !key.to_lowercase().contains("primary role") {
+            return None;
+        }
+        Some(value)
+    });
+    dbg!(leader_rank, follower_rank, primary_role);
     // dbg!(chapters.collect::<Vec<_>>());
 }