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

Author: KushalMeghani1644

clippy_dev/src/serve.rs

@@ -4,24 +4,35 @@ use core::mem;
 use std::path::Path;
 use std::process::Command;
 use std::time::{Duration, SystemTime};
+<<<<<<< HEAD
 use std::{fs, thread};
 use walkdir::WalkDir;
+=======
+use std::{env, thread};
+use std::io;
+>>>>>>> 48fa2fac9 (Refactor run and mtime functions: safer error handling, cleaner structure)
 
+/// 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.
+///
+/// # Arguments
+/// * `port` - Port to run the HTTP server on.
+/// * `lint` - Optional lint name to open directly in the browser.
 ///
-/// Panics if the python commands could not be spawned
+/// # 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}"),
     });
 
+<<<<<<< HEAD
     let mut last_update = mtime("util/gh-pages/index.html");
     loop {
         if is_metadata_outdated(mem::replace(&mut last_update, SystemTime::now())) {
@@ -54,17 +65,87 @@ pub fn run(port: u16, lint: Option<String>) -> ! {
         }
 
         // Delay to avoid updating the metadata too aggressively.
+=======
+    let mut server_started = false;
+
+    loop {
+        // 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",
+        ]
+        .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()
+                .expect("Failed to spawn cargo collect-metadata process")
+                .wait()
+                .expect("Cargo collect-metadata process failed");
+        }
+
+        // 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;
+            }
+        }
+
+>>>>>>> 48fa2fac9 (Refactor run and mtime functions: safer error handling, cleaner structure)
         thread::sleep(Duration::from_millis(1000));
     }
 }
 
+<<<<<<< HEAD
 fn log_err_and_continue<T>(res: Result<T, impl Display>, path: &Path) -> Option<T> {
     match res {
         Ok(x) => Some(x),
         Err(ref e) => {
             eprintln!("error reading `{}`: {e}", path.display());
             None
         },
+=======
+/// 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() {
+        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 {
+        Ok(path.metadata()?.modified()?)
+>>>>>>> 48fa2fac9 (Refactor run and mtime functions: safer error handling, cleaner structure)
     }
 }