extracted parse_pdses

pds_list/src/main.rs

···
-use std::collections::HashMap;
+use std::{collections::HashMap, panic, str::Lines};
 
 const JSON_URL: &str = "https://raw.githubusercontent.com/mary-ext/atproto-scraping/refs/heads/trunk/state.json";
 
···
     "atompds", "bluepds", "cirrus", "cocoon", "dnproto", "millipds", "pegasus", "rustproto", "tranquil"
 ];
 
-fn main() {
-    let data = match minreq::get(JSON_URL).send().and_then(|res| res.as_str().map(str::to_owned)) {
-        Ok(data) => data,
-        Err(err) => {
-            println!("Error downloading json: {}", err);
-            return;
-        }
-    };
-
+fn parse_pdses(mut lines_iter: Lines) -> (HashMap<String, Vec<String>>, Vec<(String, String)>) {
     let mut pds_hosts: HashMap<String, Vec<String>> = HashMap::new();
     let mut other: Vec<(String, String)> = Vec::new();
-    let mut lines_iter = data.lines();
 
-    'main: loop {
-        let line = lines_iter.next();
-
-        if line.is_none() {
-            break;
-        }
+    loop {
+        let line = lines_iter.next().expect("PDSes block ended unexpectedly!");
+        let line = line.trim_end().to_string();
 
-        let line = line.unwrap().trim_end().to_string();
+        if line.starts_with("\t\t\"http") {
+            let host = line.trim()
+                .trim_start_matches("\"https://")
+                .trim_end_matches("\": {")
+                .trim_end_matches("/");
 
-        if line == "\t\"pdses\": {" {
-            // parsing pdses section
+            let mut version: Option<String> = None;
+            let mut errored = false;
 
             loop {
-                let line = lines_iter.next();
-
-                if line.is_none() {
-                    break;
-                }
-
-                let line = line.unwrap().trim_end().to_string();
+                let line = lines_iter.next().expect("Host block ended unexpectedly!");
 
-                if line.starts_with("\t\t\"http") {
-                    let host = line.trim()
-                        .trim_start_matches("\"https://")
-                        .trim_end_matches("\": {")
-                        .trim_end_matches("/");
+                let line = line.trim_end().to_string();
 
-                    let mut version: Option<String> = None;
-                    let mut errored = false;
+                if line.starts_with("\t\t\t\"version\": \"") {
+                    let value = line.split('"').nth(3).expect("Invalid version line");
 
-                    loop {
-                        let line = lines_iter.next().expect("Host block ended unexpectedly!");
+                    if !(value.starts_with("0.") || value.starts_with("git-")) {
+                        version = Some(value.to_string());
+                    }
+                } else if line.contains("\"errorAt\":") {
+                    errored = true;
+                } else if line == "\t\t}," || line == "\t\t}" {
+                    break;
+                } else {
+                    // other host field
+                }
+            }
 
-                        let line = line.trim_end().to_string();
+            if !errored {
+                if let Some(version) = version {
+                    let mut matched = false;
 
-                        if line.starts_with("\t\t\t\"version\": \"") {
-                            let value = line.split('"').nth(3).expect("Invalid version line");
+                    for pds in PDS_TYPES {
+                        if version.contains(pds) {
+                            pds_hosts
+                                .entry(pds.to_string())
+                                .or_default()
+                                .push(host.to_string());
 
-                            if !(value.starts_with("0.") || value.starts_with("git-")) {
-                                version = Some(value.to_string());
-                            }
-                        } else if line.contains("\"errorAt\":") {
-                            errored = true;
-                        } else if line == "\t\t}," || line == "\t\t}" {
+                            matched = true;
                             break;
-                        } else {
-                            // other host field
                         }
                     }
 
-                    if !errored {
-                        if let Some(version) = version {
-                            let mut matched = false;
-
-                            for pds in PDS_TYPES {
-                                if version.contains(pds) {
-                                    pds_hosts
-                                        .entry(pds.to_string())
-                                        .or_default()
-                                        .push(host.to_string());
-
-                                    matched = true;
-                                    break;
-                                }
-                            }
-
-                            if !matched {
-                                other.push((host.to_string(), version.to_string()));
-                            }
-                        }
+                    if !matched {
+                        other.push((host.to_string(), version.to_string()));
                     }
-                } else if line == "\t}," {
-                    // end of pdses
-                    break 'main;
-                } else {
-                    println!("Unexpected line: {}", line);
-                    return;
                 }
             }
+        } else if line == "\t}," {
+            // end of pdses
+            break;
+        } else {
+            panic!("Unexpected line: {}", line);
         }
     }
 
+    return (pds_hosts, other);
+}
+
+fn main() {
+    let data = match minreq::get(JSON_URL).send().and_then(|res| res.as_str().map(str::to_owned)) {
+        Ok(data) => data,
+        Err(err) => {
+            println!("Error downloading json: {}", err);
+            return;
+        }
+    };
+
+    let mut lines_iter = data.lines();
+
+    let (pds_hosts, other) = loop {
+        let line = lines_iter.next().expect("End of file reached without finding PDSes section");
+
+        let line = line.trim_end().to_string();
+
+        if line == "\t\"pdses\": {" {
+            // parsing pdses section
+            let (pds_hosts, other) = parse_pdses(lines_iter);
+            break (pds_hosts, other);
+        } else {
+            // keep looking
+        }
+    };
+
     for pds in PDS_TYPES {
         println!("{pds}:");
 
-        for host in pds_hosts.entry(pds.to_string()).or_default() {
-            println!("  {host}");
+        if let Some(list) = pds_hosts.get(pds) {
+            for host in list {
+                println!("  {host}");
+            }
         }
 
         println!();