Merge branch 'master' into categorize-errors

Author: byfnoel

Cargo.lock

@@ -37,7 +37,7 @@ docsrs-metadata = { path = "crates/metadata" }
 anyhow = { version = "1.0.42", features = ["backtrace"]}
 backtrace = "0.3.61"
 thiserror = "2.0.3"
-comrak = { version = "0.39.0", default-features = false }
+comrak = { version = "0.40.0", default-features = false }
 syntect = { version = "5.0.0", default-features = false, features = ["parsing", "html", "dump-load", "regex-onig"] }
 toml = "0.9.2"
 prometheus = { version = "0.14.0", default-features = false }
@@ -108,7 +108,7 @@ constant_time_eq = "0.4.2"
 procfs = "0.15.1"
 
 [dev-dependencies]
-criterion = "0.6.0"
+criterion = "0.7.0"
 kuchikiki = "0.8"
 http02 = { version = "0.2.11", package = "http"}
 http-body-util = "0.1.0"
@@ -128,7 +128,7 @@ debug = "line-tables-only"
 
 [build-dependencies]
 time = "0.3"
-gix = { version = "0.72.1", default-features = false }
+gix = { version = "0.73.0", default-features = false }
 string_cache_codegen = "0.5.1"
 walkdir = "2"
 anyhow = { version = "1.0.42", features = ["backtrace"] }

Cargo.toml

@@ -2,15 +2,14 @@ use anyhow::{Context as _, Error, Result};
 use std::{env, path::Path};
 
 mod tracked {
-    use once_cell::sync::Lazy;
     use std::{
         collections::HashSet,
         io::{Error, Result},
         path::{Path, PathBuf},
-        sync::Mutex,
+        sync::{LazyLock, Mutex},
     };
 
-    static SEEN: Lazy<Mutex<HashSet<PathBuf>>> = Lazy::new(|| Mutex::new(HashSet::new()));
+    static SEEN: LazyLock<Mutex<HashSet<PathBuf>>> = LazyLock::new(|| Mutex::new(HashSet::new()));
 
     pub(crate) fn track(path: impl AsRef<Path>) -> Result<()> {
         let path = path.as_ref();

build.rs

@@ -1,2 +1,3 @@
 [toolchain]
 channel = "1.88.0"
+components = ["rustfmt", "clippy"]

rust-toolchain.toml

@@ -1,9 +1,9 @@
 use mime::Mime;
-use once_cell::sync::Lazy;
+use std::sync::LazyLock;
 
 macro_rules! mime {
     ($id:ident, $mime:expr) => {
-        pub(crate) static $id: Lazy<Mime> = Lazy::new(|| $mime.parse().unwrap());
+        pub(crate) static $id: LazyLock<Mime> = LazyLock::new(|| $mime.parse().unwrap());
     };
 }
 

src/db/mimes.rs

@@ -5,10 +5,10 @@ use crate::{Config, db::Pool};
 use async_trait::async_trait;
 use chrono::{DateTime, Utc};
 use futures_util::stream::TryStreamExt;
-use once_cell::sync::Lazy;
 use regex::Regex;
 use std::collections::{HashMap, HashSet};
 use std::fmt;
+use std::sync::LazyLock;
 use tracing::{debug, info, trace, warn};
 
 #[async_trait]
@@ -309,7 +309,7 @@ impl RepositoryStatsUpdater {
 }
 
 pub(crate) fn repository_name(url: &str) -> Option<RepositoryName> {
-    static RE: Lazy<Regex> = Lazy::new(|| {
+    static RE: LazyLock<Regex> = LazyLock::new(|| {
         Regex::new(r"https?://(?P<host>[^/]+)/(?P<owner>[\w\._/-]+)/(?P<repo>[\w\._-]+)").unwrap()
     });
 

src/repositories/updater.rs

@@ -253,40 +253,6 @@ impl AsyncStorage {
         }
     }
 
-    /// Fetch a rustdoc file from our blob storage.
-    /// * `name` - the crate name
-    /// * `version` - the crate version
-    /// * `latest_build_id` - the id of the most recent build. used purely to invalidate the local archive
-    ///   index cache, when `archive_storage` is `true.` Without it we wouldn't know that we have
-    ///   to invalidate the locally cached file after a rebuild.
-    /// * `path` - the wanted path inside the documentation.
-    /// * `archive_storage` - if `true`, we will assume we have a remove ZIP archive and an index
-    ///    where we can fetch the requested path from inside the ZIP file.
-    #[instrument]
-    pub(crate) async fn fetch_rustdoc_file(
-        &self,
-        name: &str,
-        version: &str,
-        latest_build_id: Option<BuildId>,
-        path: &str,
-        archive_storage: bool,
-    ) -> Result<Blob> {
-        trace!("fetch rustdoc file");
-        Ok(if archive_storage {
-            self.get_from_archive(
-                &rustdoc_archive_path(name, version),
-                latest_build_id,
-                path,
-                self.max_file_size_for(path),
-            )
-            .await?
-        } else {
-            // Add rustdoc prefix, name and version to the path for accessing the file stored in the database
-            let remote_path = format!("rustdoc/{name}/{version}/{path}");
-            self.get(&remote_path, self.max_file_size_for(path)).await?
-        })
-    }
-
     /// Fetch a rustdoc file from our blob storage.
     /// * `name` - the crate name
     /// * `version` - the crate version
@@ -840,23 +806,6 @@ impl Storage {
             .block_on(self.inner.set_public_access(path, public))
     }
 
-    pub(crate) fn fetch_rustdoc_file(
-        &self,
-        name: &str,
-        version: &str,
-        latest_build_id: Option<BuildId>,
-        path: &str,
-        archive_storage: bool,
-    ) -> Result<Blob> {
-        self.runtime.block_on(self.inner.fetch_rustdoc_file(
-            name,
-            version,
-            latest_build_id,
-            path,
-            archive_storage,
-        ))
-    }
-
     pub(crate) fn fetch_source_file(
         &self,
         name: &str,

src/storage/mod.rs

@@ -289,7 +289,9 @@ impl AxumRouterTestExt for axum::Router {
         // }
 
         if redirect_target != expected_target {
-            anyhow::bail!("got redirect to {redirect_target}");
+            anyhow::bail!(
+                "got redirect to `{redirect_target}`, expected redirect to `{expected_target}`",
+            );
         }
 
         Ok(response)