Update after review

Signed-off-by: Nicolae Dicu <[email protected]>

Author: nicu1989

crates/analyzer/src/analyze/crate_.rs

@@ -10,7 +10,7 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
     // make the path absolute
     // TODO we use dunce to canonicalize the path because otherwise there is issues with python's os.path.relpath on windows, but maybe we should fix this on the Python side
     let crate_dir =
-        dunce::canonicalize(path).context(format!("Error resolving crate path: {}", path))?;
+        dunce::canonicalize(path).context(format!("Error resolving crate path: {path}"))?;
     eprintln!("running new analyzer");
     // check the path is a directory
     if !crate_dir.is_dir() {
@@ -43,7 +43,12 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
         .targets
         .iter()
         .find(|t| t.kind.contains(&"lib".into()))
-        .or_else(|| root_pkg.targets.iter().find(|t| t.kind.contains(&"bin".into())))
+        .or_else(|| {
+            root_pkg
+                .targets
+                .iter()
+                .find(|t| t.kind.contains(&"bin".into()))
+        })
         .ok_or_else(|| anyhow!("No lib or bin target defined in manifest"))?;
 
     let crate_name = root_target.name.clone();
@@ -61,15 +66,11 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
 
     // read the top-level module
     let content = std::fs::read_to_string(&root_module)?;
-    let (module, structs, enums, functions) = Module::parse(
-        Some(&root_module),
-        &[&result.crate_.name],
-        &content,
-    )
-    .context(format!(
-        "Error parsing module {}",
-        root_module.to_string_lossy()
-    ))?;
+    let (module, structs, enums, functions) =
+        Module::parse(Some(&root_module), &[&result.crate_.name], &content).context(format!(
+            "Error parsing module {}",
+            root_module.to_string_lossy()
+        ))?;
 
     let mut modules_to_read = module
         .declarations
@@ -91,20 +92,21 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
     // recursively find/read the public sub‑modules
     let mut read_modules = vec![];
     while let Some((parent_dir, module_name, parent)) = modules_to_read.pop() {
-        let (module_path, submodule_dir) = if parent_dir.join(&module_name).with_extension("rs").exists() {
-            (
-                parent_dir.join(&module_name).with_extension("rs"),
-                parent_dir.join(&module_name),
-            )
-        } else if parent_dir.join(&module_name).join("mod.rs").exists() {
-            (
-                parent_dir.join(&module_name).join("mod.rs"),
-                parent_dir.to_path_buf(),
-            )
-        } else {
-            // TODO warn about missing module?
-            continue;
-        };
+        let (module_path, submodule_dir) =
+            if parent_dir.join(&module_name).with_extension("rs").exists() {
+                (
+                    parent_dir.join(&module_name).with_extension("rs"),
+                    parent_dir.join(&module_name),
+                )
+            } else if parent_dir.join(&module_name).join("mod.rs").exists() {
+                (
+                    parent_dir.join(&module_name).join("mod.rs"),
+                    parent_dir.to_path_buf(),
+                )
+            } else {
+                // TODO warn about missing module?
+                continue;
+            };
 
         if read_modules.contains(&module_path) {
             continue;

crates/py_binding/src/data_query.rs

@@ -26,8 +26,7 @@ where
         Ok(crate_) => crate_,
         Err(err) => {
             return Err(PyIOError::new_err(format!(
-                "Could not deserialize {}: {}",
-                name, err
+                "Could not deserialize {name}: {err}"
             )))
         }
     };
@@ -39,7 +38,7 @@ where
 pub fn load_crate(cache_path: &str, name: &str) -> PyResult<Option<Crate>> {
     let path = std::path::Path::new(cache_path)
         .join("crates")
-        .join(format!("{}.json", name));
+        .join(format!("{name}.json"));
     if !path.exists() {
         return Ok(None);
     }
@@ -53,7 +52,7 @@ pub fn load_crate(cache_path: &str, name: &str) -> PyResult<Option<Crate>> {
 pub fn load_module(cache_path: &str, full_name: &str) -> PyResult<Option<Module>> {
     let path = std::path::Path::new(cache_path)
         .join("modules")
-        .join(format!("{}.json", full_name));
+        .join(format!("{full_name}.json"));
     if !path.exists() {
         return Ok(None);
     }
@@ -67,7 +66,7 @@ pub fn load_module(cache_path: &str, full_name: &str) -> PyResult<Option<Module>
 pub fn load_struct(cache_path: &str, full_name: &str) -> PyResult<Option<Struct>> {
     let path = std::path::Path::new(cache_path)
         .join("structs")
-        .join(format!("{}.json", full_name));
+        .join(format!("{full_name}.json"));
     if !path.exists() {
         return Ok(None);
     }
@@ -81,7 +80,7 @@ pub fn load_struct(cache_path: &str, full_name: &str) -> PyResult<Option<Struct>
 pub fn load_enum(cache_path: &str, full_name: &str) -> PyResult<Option<Enum>> {
     let path = std::path::Path::new(cache_path)
         .join("enums")
-        .join(format!("{}.json", full_name));
+        .join(format!("{full_name}.json"));
     if !path.exists() {
         return Ok(None);
     }
@@ -95,7 +94,7 @@ pub fn load_enum(cache_path: &str, full_name: &str) -> PyResult<Option<Enum>> {
 pub fn load_function(cache_path: &str, full_name: &str) -> PyResult<Option<Function>> {
     let path = std::path::Path::new(cache_path)
         .join("functions")
-        .join(format!("{}.json", full_name));
+        .join(format!("{full_name}.json"));
     if !path.exists() {
         return Ok(None);
     }
@@ -106,14 +105,8 @@ pub fn load_function(cache_path: &str, full_name: &str) -> PyResult<Option<Funct
 
 /// Check if a path is a child of a given parent, and return the fully qualified name of the child.
 fn is_child(path: &std::path::PathBuf, parent: &Vec<String>) -> Option<String> {
-    let name = match path.file_stem() {
-        Some(name) => name,
-        None => return None,
-    };
-    let name = match name.to_str() {
-        Some(name) => name,
-        None => return None,
-    };
+    let name = path.file_stem()?;
+    let name = name.to_str()?;
     let name_path = name.split("::").collect::<Vec<_>>();
     if name_path.len() != parent.len() + 1 {
         return None;

crates/py_binding/src/lib.rs

@@ -162,25 +162,20 @@ where
         Ok(value) => value,
         Err(err) => {
             return Err(PyIOError::new_err(format!(
-                "Could not serialize value: {}",
-                err
+                "Could not serialize value: {err}"
             )))
         }
     };
     if path.exists() {
-        match std::fs::read_to_string(path) {
-            Ok(old_value) => {
-                if value == old_value {
-                    return Ok(());
-                }
+        if let Ok(old_value) = std::fs::read_to_string(path) {
+            if value == old_value {
+                return Ok(());
             }
-            Err(_) => {}
         };
     }
     match std::fs::write(path, value) {
         Err(err) => Err(PyIOError::new_err(format!(
-            "Could not write value to file: {}",
-            err
+            "Could not write value to file: {err}"
         ))),
         Ok(_) => Ok(()),
     }

pyproject.toml

@@ -37,7 +37,7 @@ classifiers = [
   "Topic :: Text Processing :: Markup",
 ]
 dependencies = [
-  "sphinx>=7.3"
+  "sphinx>=8,<9"
 ]
 
 [project.urls]

python/sphinx_rust/directives/_core.py

@@ -31,7 +31,7 @@ class RustAutoDirective(SphinxDirective):
 
     @property
     def doc(self) -> nodes.document:
-        return self.state.document  # type: ignore[no-any-return]
+        return self.state.document
 
     @property
     def rust_config(self) -> RustConfig:

python/sphinx_rust/domain.py

@@ -3,9 +3,9 @@
 from dataclasses import dataclass
 import os
 from pathlib import Path
+import re
 import shutil
 from typing import TYPE_CHECKING, Literal, TypedDict
-import re
 
 from sphinx import addnodes
 from sphinx.domains import Domain
@@ -21,7 +21,6 @@
 from sphinx_rust.directives.struct import RustStructAutoDirective
 from sphinx_rust.sphinx_rust import analyze_crate, load_descendant_modules
 
-
 INVALID_CHARS = r"[^A-Za-z0-9._-]"
 
 
@@ -34,6 +33,7 @@ def slugify_rust_name(fullname: str) -> Path:
     cleaned = [re.sub(INVALID_CHARS, "_", p) for p in parts]
     return Path(*cleaned)
 
+
 if TYPE_CHECKING:
     from docutils.nodes import Element
     from sphinx.addnodes import pending_xref
@@ -248,7 +248,7 @@ def create_object_pages(folder: Path, otype: str, names: list[str]) -> None:
         "",
         ".. toctree::",
         "    :maxdepth: 1",
-        ""
+        "",
     ]
 
     for rust_name in names:
@@ -280,12 +280,14 @@ def create_code_pages(crate_name: str, srcdir: Path, cache: Path) -> None:
             dst.parent.mkdir(parents=True, exist_ok=True)
 
             dst.write_text(
-                "\n".join((
-                    ":orphan:",
-                    "",
-                    f".. literalinclude:: {os.path.relpath(file_path, dst.parent)}",
-                    f"   :name: rust-code:{full_name}",
-                    "   :language: rust",
-                    "   :linenos:",
-                ))
+                "\n".join(
+                    (
+                        ":orphan:",
+                        "",
+                        f".. literalinclude:: {os.path.relpath(file_path, dst.parent)}",
+                        f"   :name: rust-code:{full_name}",
+                        "   :language: rust",
+                        "   :linenos:",
+                    )
+                )
             )