Store module file path in analysis (#11)

Author: chrisjsewell

crates/analyzer/src/analyze/crate_.rs

@@ -5,11 +5,13 @@ use serde::{Deserialize, Serialize};
 use super::{Enum, Module, Struct};
 
 pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
+    // make the path absolute
+    let path =
+        std::fs::canonicalize(path).context(format!("Error resolving crate path: {}", path))?;
     // check the path is a directory
-    let path = std::path::Path::new(path);
     if !path.is_dir() {
         return Err(anyhow::anyhow!(format!(
-            "Path is not a directory: {}",
+            "Crate path is not a directory: {}",
             path.to_string_lossy()
         )));
     }
@@ -73,10 +75,11 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
 
     // read the top-level module
     let content = std::fs::read_to_string(&root_file)?;
-    let (module, structs, enums) = Module::parse(&[&crate_.name], &content).context(format!(
-        "Error parsing module {}",
-        root_file.to_string_lossy()
-    ))?;
+    let (module, structs, enums) = Module::parse(Some(&root_file), &[&crate_.name], &content)
+        .context(format!(
+            "Error parsing module {}",
+            root_file.to_string_lossy()
+        ))?;
     result_.crate_.docstring = module.docstring.clone();
     let mut modules_to_read = module
         .declarations
@@ -119,6 +122,7 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
         let content = std::fs::read_to_string(&module_path)?;
         let path: Vec<String> = [&parent[..], &[module_name]].concat();
         let (module, structs, enums) = Module::parse(
+            Some(&module_path),
             &path.iter().map(|s| s.as_str()).collect::<Vec<&str>>(),
             &content,
         )
@@ -256,22 +260,29 @@ mod tests {
         )?;
 
         // Analyze the dummy crate
-        let crate_ = analyze_crate(temp_dir_path.to_str().unwrap())?;
+        let mut result = analyze_crate(temp_dir_path.to_str().unwrap())?;
 
-        assert_yaml_snapshot!(crate_, @r###"
+        // Remove the file paths for snapshot testing, as they are non-deterministic
+        for module in result.modules.iter_mut() {
+            module.file = None;
+        }
+
+        assert_yaml_snapshot!(result, @r###"
         ---
         crate_:
           name: my_crate
           version: 0.1.0
           docstring: The crate docstring
         modules:
-          - path:
+          - file: ~
+            path:
               - my_crate
               - my_module
             docstring: The module docstring
             declarations:
               - my_submodule
-          - path:
+          - file: ~
+            path:
               - my_crate
               - my_module
               - my_submodule

crates/analyzer/src/analyze/module.rs

@@ -1,4 +1,6 @@
 //! Analyze modules
+use std::path::Path;
+
 use anyhow::Result;
 use serde::{Deserialize, Serialize};
 use syn::parse_file;
@@ -13,6 +15,8 @@ use super::{docstring_from_attrs, enum_::Enum, struct_::Struct};
 ///     :tags: rust
 ///     :status: in-progress
 pub struct Module {
+    /// The path to the module file
+    pub file: Option<String>,
     /// The fully qualified name of the module
     pub path: Vec<String>,
     pub docstring: String,
@@ -26,9 +30,14 @@ impl Module {
         self.path.join("::")
     }
     /// Extract the relevant information from the AST
-    pub fn parse(path: &[&str], content: &str) -> Result<(Self, Vec<Struct>, Vec<Enum>)> {
+    pub fn parse(
+        file: Option<&Path>,
+        path: &[&str],
+        content: &str,
+    ) -> Result<(Self, Vec<Struct>, Vec<Enum>)> {
         let syntax = parse_file(content)?;
         let mut mod_ = Self {
+            file: file.map(|f| f.to_string_lossy().to_string()), // TODO better way to serialize the path, also ?
             path: path.iter().map(|s| s.to_string()).collect(),
             docstring: docstring_from_attrs(&syntax.attrs),
             declarations: vec![],
@@ -76,7 +85,7 @@ mod tests {
     use insta::assert_yaml_snapshot;
 
     #[test]
-    fn test_parse_enum() {
+    fn test_parse_module() {
         let content = r###"
 //! Multi-line
 //! docstring
@@ -85,10 +94,11 @@ pub enum MyEnum {
     MyVariant1,
 }
 "###;
-        let mod_ = Module::parse(&["test"], content).unwrap();
+        let mod_ = Module::parse(None, &["test"], content).unwrap();
         assert_yaml_snapshot!(mod_, @r###"
         ---
-        - path:
+        - file: ~
+          path:
             - test
           docstring: "Multi-line\ndocstring"
           declarations: []

crates/py_binding/src/objects.rs

@@ -43,6 +43,8 @@ impl From<analyze::Crate> for Crate {
 #[derive(Clone)]
 /// pyo3 representation of a module
 pub struct Module {
+    #[pyo3(get)]
+    pub file: Option<String>,
     #[pyo3(get)]
     pub path: Vec<String>,
     #[pyo3(get)]
@@ -67,6 +69,7 @@ impl Module {
 impl From<analyze::Module> for Module {
     fn from(module: analyze::Module) -> Self {
         Module {
+            file: module.file,
             path: module.path,
             docstring: module.docstring,
         }

python/sphinx_rust/sphinx_rust.pyi

@@ -89,6 +89,8 @@ class Crate:
 class Module:
     """Representation of a module."""
 
+    file: str | None
+    """The absolute path to the file containing the module."""
     name: str
     """The name of the module."""
     path: list[str]