Refactor run and mtime functions: safer error handling, cleaner structure

Author: KushalMeghani1644

clippy_dev/src/serve.rs

@@ -2,72 +2,96 @@ use std::path::Path;
 use std::process::Command;
 use std::time::{Duration, SystemTime};
 use std::{env, thread};
+use std::io;
 
+/// Python binary depending on OS
 #[cfg(windows)]
 const PYTHON: &str = "python";
-
 #[cfg(not(windows))]
 const PYTHON: &str = "python3";
 
-/// # Panics
+/// Run a local live server for Clippy docs and lints.
 ///
-/// Panics if the python commands could not be spawned
+/// # Arguments
+/// * `port` - Port to run the HTTP server on.
+/// * `lint` - Optional lint name to open directly in the browser.
+///
+/// # Panics
+/// Panics if spawning processes fails or the HTTP server cannot be launched.
 pub fn run(port: u16, lint: Option<String>) -> ! {
     let mut url = Some(match lint {
-        None => format!("http://localhost:{port}"),
         Some(lint) => format!("http://localhost:{port}/#{lint}"),
+        None => format!("http://localhost:{port}"),
     });
 
+    let mut server_started = false;
+
     loop {
-        let index_time = mtime("util/gh-pages/index.html");
+        // Check last modified times of critical files
+        let index_time = mtime("util/gh-pages/index.html").unwrap_or(SystemTime::UNIX_EPOCH);
         let times = [
             "clippy_lints/src",
             "util/gh-pages/index_template.html",
             "tests/compile-test.rs",
         ]
-        .map(mtime);
+        .iter()
+        .filter_map(|p| mtime(p).ok())
+        .collect::<Vec<_>>();
 
+        // Rebuild metadata if any file is newer than index.html
         if times.iter().any(|&time| index_time < time) {
             Command::new(env::var("CARGO").unwrap_or_else(|_| "cargo".into()))
                 .arg("collect-metadata")
                 .spawn()
-                .unwrap()
+                .expect("Failed to spawn cargo collect-metadata process")
                 .wait()
-                .unwrap();
+                .expect("Cargo collect-metadata process failed");
         }
-        if let Some(url) = url.take() {
-            thread::spawn(move || {
-                let mut child = Command::new(PYTHON)
-                    .arg("-m")
-                    .arg("http.server")
-                    .arg(port.to_string())
-                    .current_dir("util/gh-pages")
-                    .spawn()
-                    .unwrap();
-                // Give some time for python to start
-                thread::sleep(Duration::from_millis(500));
-                // Launch browser after first export.py has completed and http.server is up
-                let _result = opener::open(url);
-                child.wait().unwrap();
-            });
+
+        // Start HTTP server and open browser once
+        if !server_started {
+            if let Some(url) = url.take() {
+                thread::spawn(move || {
+                    let mut child = Command::new(PYTHON)
+                        .arg("-m")
+                        .arg("http.server")
+                        .arg(port.to_string())
+                        .current_dir("util/gh-pages")
+                        .spawn()
+                        .expect("Failed to spawn Python HTTP server");
+
+                    // Wait until server starts
+                    thread::sleep(Duration::from_millis(500));
+
+                    // Open browser after first export
+                    let _ = opener::open(url);
+
+                    child.wait().expect("Python HTTP server process failed");
+                });
+                server_started = true;
+            }
         }
+
         thread::sleep(Duration::from_millis(1000));
     }
 }
 
-fn mtime(path: impl AsRef<Path>) -> SystemTime {
+/// Get the most recent modification time of a file or directory recursively.
+/// Returns `io::Result<SystemTime>`.
+fn mtime(path: impl AsRef<Path>) -> io::Result<SystemTime> {
     let path = path.as_ref();
+
     if path.is_dir() {
-        path.read_dir()
-            .into_iter()
-            .flatten()
-            .flatten()
-            .map(|entry| mtime(entry.path()))
-            .max()
-            .unwrap_or(SystemTime::UNIX_EPOCH)
+        let mut latest = SystemTime::UNIX_EPOCH;
+        for entry in path.read_dir()? {
+            let entry = entry?;
+            let entry_time = mtime(entry.path())?;
+            if entry_time > latest {
+                latest = entry_time;
+            }
+        }
+        Ok(latest)
     } else {
-        path.metadata()
-            .and_then(|metadata| metadata.modified())
-            .unwrap_or(SystemTime::UNIX_EPOCH)
+        Ok(path.metadata()?.modified()?)
     }
 }