Fix: Use cargo_metadata for Cargo.toml parsing

The module used old implementation of Cargo.toml parsing.

Resolves: eclipse-score/score#1522

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

Author: nicu1989

README.md

@@ -10,135 +10,3 @@ See [docs/](docs/) for more information.
 
 [pypi-badge]: https://img.shields.io/pypi/v/sphinx-rust.svg
 [pypi-link]: https://pypi.org/project/sphinx-rust
-
-## Fork notes
-
-### Integration, usage and testing
-
-**CURRENTLY FORK UNDER DEVELOPMENT! - PIP PACKAGE UNAVAILABLE**
-
-* In order to integrate in score:
-
-Update score/docs/conf.py :
-
-```python
-extensions = [
-    "sphinx_rust",
-    ...
-]
-
-# point to a rust crate in score(create a dummy one for testing if unavailable)
-rust_crates = [
-    "../rust-crates/dummy_crate",
-]
-```
-In index.rst :
-```
-Rust API <api/crates/dummy_crate/index>
-```
-
-* Testing in score repo:
-
-For fast development it is recomended to convert sphinx-rust module to bazel module by creating:
-
-- __sphinx-rust__/BUILD.bazel:
-
-```python
-load("@rules_python//python:defs.bzl", "py_library")
-
-py_library(
-    name = "sphinx_rust",
-    srcs = glob(["python/sphinx_rust/**/*.py"]),
-    data = glob([
-        "python/sphinx_rust/sphinx_rust.cpython-312-*.so",
-    ]),
-    imports = ["python"],
-    visibility = ["//visibility:public"],
-)
-```
-
-- __sphinx-rust__/MODULE.bazel
-
-```python
-module(name = "sphinx_rust", version = "0.0.0-dev")
-bazel_dep(name = "rules_python", version = "1.4.1")
-```
-
-Now we can add the __sphinx_rust__ module directly in __score__:
-
-- __score__/MODULE.bazel:
-
-```python
-bazel_dep(name = "sphinx_rust", version = "0.0.0-dev")
-local_path_override(module_name = "sphinx_rust", path = "../sphinx-rust")
-```
-
-- __docs-as-code__/docs.bzl:
-
-```python
-def _incremental ...
-
-    py_binary(
-        name = incremental_name,
-        srcs = ["@score_docs_as_code//src:incremental.py"],
-        deps = dependencies + ["@sphinx_rust//:sphinx_rust"],
-```
-
-- create the dummy_crate in __score__ with the following structure and content:
-
-```sh
-../score/rust-crates/
-└── dummy_crate
-    ├── Cargo.toml
-    └── src
-        └── lib.rs
-```
-
-Cargo.toml:
-
-```yaml
-[package]
-name = "dummy_crate"
-version = "0.1.0"
-edition = "2021"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-
-[lib]
-name = "dummy_crate"
-```
-
-lib.rs:
-
-```rs
-pub fn add(left: usize, right: usize) -> usize {
-    left + right
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn it_works() {
-        let result = add(2, 2);
-        assert_eq!(result, 4);
-    }
-}
-```
-
-It can be tested using requirements.in from docs-as-code as well but this is not that reliable as bazel will cache sphinx-rust:
-
-- in __docs-as-code__/src/requirements.in:
-
-```python
-sphinx-rust @ file:///mnt/d/qorix/forks/sphinx-rust
-```
-
-- run pip packages update:
-
-```sh
-bazel run //src:requirements.update
-```

crates/analyzer/Cargo.toml

@@ -20,6 +20,7 @@ serde.workspace = true
 serde_json.workspace = true
 syn.workspace = true
 toml.workspace = true
+cargo_metadata = "0.18"
 
 [dev-dependencies]
 insta.workspace = true

crates/analyzer/src/analyze/crate_.rs

@@ -1,79 +1,76 @@
 //! Analyze the crate
-use anyhow::{Context, Result};
+use anyhow::{anyhow, Context, Result};
+use cargo_metadata::{MetadataCommand, Target};
 use serde::{Deserialize, Serialize};
+use std::path::PathBuf;
 
 use crate::data_model::{Crate, Enum, Function, Module, Struct};
 
 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 path =
+    let crate_dir =
         dunce::canonicalize(path).context(format!("Error resolving crate path: {}", path))?;
+    eprintln!("running new analyzer");
     // check the path is a directory
-    if !path.is_dir() {
-        return Err(anyhow::anyhow!(format!(
+    if !crate_dir.is_dir() {
+        return Err(anyhow!(
             "Crate path is not a directory: {}",
-            path.to_string_lossy()
-        )));
+            crate_dir.to_string_lossy()
+        ));
     }
     // check if Cargo.toml exists
-    let cargo_toml_path = path.join("Cargo.toml");
+    let cargo_toml_path = crate_dir.join("Cargo.toml");
     if !cargo_toml_path.exists() {
-        return Err(anyhow::anyhow!(format!(
+        return Err(anyhow!(
             "Cargo.toml does not exist in: {}",
-            path.to_string_lossy()
-        )));
+            crate_dir.to_string_lossy()
+        ));
     }
 
-    // read the Cargo.toml and initialize the Crate struct
-    let contents = std::fs::read_to_string(&cargo_toml_path)?;
-    let cargo_toml: CargoToml = toml::from_str(&contents).context(format!(
-        "Error parsing: {}",
-        cargo_toml_path.to_string_lossy()
-    ))?;
+    // use `cargo_metadata` instead of implementing own TOML parser
+    let metadata = MetadataCommand::new()
+        .manifest_path(&cargo_toml_path)
+        .exec()
+        .context("Failed to run `cargo metadata`")?;
 
-    // check whether the crate is a library or binary
-    let (crate_name, to_root) = if let Some(lib) = cargo_toml.lib {
-        if cargo_toml.bin.is_some() {
-            return Err(anyhow::anyhow!(format!(
-                "Both lib and bin sections in: {}",
-                path.to_string_lossy()
-            )));
-        }
-        (
-            lib.name.unwrap_or(cargo_toml.package.name),
-            lib.path.unwrap_or("src/lib.rs".to_string()),
-        )
-    } else if let Some(bin) = cargo_toml.bin {
-        (
-            bin.name.unwrap_or(cargo_toml.package.name),
-            bin.path.unwrap_or("src/main.rs".to_string()),
-        )
-    } else {
-        return Err(anyhow::anyhow!(format!(
-            "No lib or bin section in: {}",
-            path.to_string_lossy()
-        )));
-    };
+    let root_pkg = metadata
+        .root_package()
+        .ok_or_else(|| anyhow!("`cargo metadata` returned no root package"))?;
+
+    // Prefer library target; fall back to the first binary target
+    let root_target: &Target = root_pkg
+        .targets
+        .iter()
+        .find(|t| t.kind.contains(&"lib".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();
+    let root_module = PathBuf::from(&root_target.src_path);
 
     let mut result = AnalysisResult::new(Crate {
-        name: crate_name,
-        version: cargo_toml.package.version.clone(),
+        name: crate_name.clone(),
+        version: root_pkg.version.to_string(), // workspace-aware
     });
 
     // check existence of the root module
-    let root_module = path.join(to_root);
     if !root_module.exists() {
         return Ok(result);
     }
 
     // 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
         .iter()
@@ -91,24 +88,23 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
     result.enums.extend(enums);
     result.functions.extend(functions);
 
-    // recursively find/read the public sub-modules
+    // 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;
@@ -126,12 +122,12 @@ pub fn analyze_crate(path: &str) -> Result<AnalysisResult> {
             "Error parsing module {}",
             module_path.to_string_lossy()
         ))?;
+
         modules_to_read.extend(
             module
                 .declarations
                 .iter()
-                .map(|s| (submodule_dir.clone(), s.to_string(), path.clone()))
-                .collect::<Vec<_>>(),
+                .map(|s| (submodule_dir.clone(), s.to_string(), path.clone())),
         );
         result.modules.push(module);
         result.structs.extend(structs);
@@ -164,31 +160,6 @@ impl AnalysisResult {
     }
 }
 
-#[derive(Debug, Deserialize)]
-struct CargoToml {
-    package: Package,
-    bin: Option<Bin>,
-    lib: Option<Lib>,
-}
-
-#[derive(Debug, Deserialize)]
-struct Package {
-    name: String,
-    version: String,
-}
-
-#[derive(Debug, Deserialize)]
-struct Lib {
-    name: Option<String>,
-    path: Option<String>,
-}
-
-#[derive(Debug, Deserialize)]
-struct Bin {
-    name: Option<String>,
-    path: Option<String>,
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;

crates/py_binding/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "sphinx_rust"
-version = "0.0.2"
+version = "0.0.2-dev1"
 publish = false
 edition = "2021"
 authors.workspace = true