Added fetch-segment

Author: LeBoufty

README.md

@@ -39,6 +39,12 @@ You can also specify an output file as with `fetch`.
 cargo run -- -o builds.json fetch-latest 20 # Fetches the twenty latest public builds and saves them to builds.json
 ```
 
+### Get a batch of build orders
+
+```Bash
+cargo run fetch-segment 141 145 # Fetches build orders 141-145 (both included)
+```
+
 ## Roadmap
 
 * [ ] Better CLI interface, with progress bars, styling and more detailed progress

src/handlers.rs

@@ -0,0 +1,70 @@
+use crate::build_order::{BuildOrder, BuildOrderError};
+use crate::build_parser::fetch_build_order;
+use crate::index_manager::{LOWEST_INDEX, get_st_highest_index};
+
+pub fn fetch_latest(count: u32) -> Vec<BuildOrder> {
+    let highest_index = get_st_highest_index();
+    let mut end_index = if count > highest_index - LOWEST_INDEX {
+        LOWEST_INDEX
+    } else {
+        highest_index - count + 1
+    };
+    let mut increment = 0;
+    let mut current_id = highest_index;
+    let mut build_orders = Vec::new();
+    while current_id >= end_index && build_orders.len() < count as usize {
+        current_id = highest_index - increment;
+        match fetch_build_order(current_id) {
+            Ok(build_order) => {
+                build_orders.push(build_order);
+                increment += 1;
+            }
+            Err(e) => {
+                if e.eq(&BuildOrderError::Cloaked) {
+                    eprintln!("Build order {} is cloaked, skipping.", current_id);
+                    end_index = if end_index > LOWEST_INDEX {
+                        end_index - 1
+                    } else {
+                        LOWEST_INDEX
+                    } // Decrease end_index to compensate for the skipped build
+                } else {
+                    eprintln!("Error fetching build order {}: {}", current_id, e);
+                }
+                increment += 1; // Increment to avoid infinite loop
+                continue; // Some builds might not be available, continue fetching
+            }
+        }
+    }
+    build_orders
+}
+
+pub fn fetch_segment(start: u32, end: u32) -> Vec<BuildOrder> {
+    let highest_index = get_st_highest_index();
+    let start = if start < LOWEST_INDEX {
+        LOWEST_INDEX
+    } else {
+        start
+    };
+    let end = if end > highest_index {
+        highest_index
+    } else {
+        end
+    };
+
+    if start > end {
+        eprintln!(
+            "Start index {} is greater than end index {}. Returning empty segment.",
+            start, end
+        );
+        return Vec::new();
+    }
+
+    let mut build_orders = Vec::new();
+    for id in (start..=end).rev() {
+        match fetch_build_order(id) {
+            Ok(build_order) => build_orders.push(build_order),
+            Err(e) => eprintln!("Error fetching build order {}: {}", id, e),
+        }
+    }
+    build_orders
+}

src/lib.rs

@@ -1,5 +1,6 @@
 pub mod build_order;
 pub mod build_parser;
 pub mod build_regex;
+pub mod handlers;
 pub mod http_client;
 pub mod index_manager;

src/main.rs

@@ -1,5 +1,6 @@
-use build_warren::index_manager::{LOWEST_INDEX, get_st_highest_index};
-use build_warren::{build_order::BuildOrderError, build_parser::fetch_build_order};
+use build_warren::build_parser::fetch_build_order;
+use build_warren::handlers::{fetch_latest, fetch_segment};
+use build_warren::index_manager::get_st_highest_index;
 use clap::{Parser, Subcommand};
 use serde_json;
 use std::fs;
@@ -31,6 +32,14 @@ enum Commands {
         #[arg(default_value_t = 1)]
         count: u32,
     },
+
+    /// Fetch a segment of build orders
+    FetchSegment {
+        /// The starting index of the segment
+        start: u32,
+        /// The ending index of the segment
+        end: u32,
+    },
 }
 
 fn main() {
@@ -60,38 +69,7 @@ fn main() {
             Err(e) => eprintln!("Error fetching build order: {}", e),
         },
         Some(Commands::FetchLatest { count }) => {
-            let highest_index = get_st_highest_index();
-            let mut end_index = if *count > highest_index - LOWEST_INDEX {
-                LOWEST_INDEX
-            } else {
-                highest_index - *count + 1
-            };
-            let mut increment = 0;
-            let mut current_id = highest_index;
-            let mut build_orders = Vec::new();
-            while current_id >= end_index && build_orders.len() < *count as usize {
-                current_id = highest_index - increment;
-                match fetch_build_order(current_id) {
-                    Ok(build_order) => {
-                        build_orders.push(build_order);
-                        increment += 1;
-                    }
-                    Err(e) => {
-                        if e.eq(&BuildOrderError::Cloaked) {
-                            eprintln!("Build order {} is cloaked, skipping.", current_id);
-                            end_index = if end_index > LOWEST_INDEX {
-                                end_index - 1
-                            } else {
-                                LOWEST_INDEX
-                            } // Decrease end_index to compensate for the skipped build
-                        } else {
-                            eprintln!("Error fetching build order {}: {}", current_id, e);
-                        }
-                        increment += 1; // Increment to avoid infinite loop
-                        continue; // Some builds might not be available, continue fetching
-                    }
-                }
-            }
+            let build_orders = fetch_latest(*count);
             let json_output = serde_json::to_string_pretty(&build_orders)
                 .expect("Failed to serialize build orders to JSON");
             if let Some(output_file) = &cli.output {
@@ -104,5 +82,16 @@ fn main() {
         None => {
             eprintln!("No command provided. Use --help to see available commands.");
         }
+        Some(Commands::FetchSegment { start, end }) => {
+            let build_orders = fetch_segment(*start, *end);
+            let json_output = serde_json::to_string_pretty(&build_orders)
+                .expect("Failed to serialize build orders to JSON");
+            if let Some(output_file) = &cli.output {
+                fs::write(output_file, json_output)
+                    .expect("Failed to write build orders to output file");
+            } else {
+                println!("{}", json_output);
+            }
+        }
     }
 }