r2x-ast 0.1.10

AST discovery utilities for the r2x CLI
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143

//! pyproject.toml entry point parser (PEP 621)
//!
//! Parses entry points from pyproject.toml files for plugin discovery.

use crate::discovery_types::EntryPointInfo;
use crate::entry_points::parser::{is_r2x_section, parse_entry_point_line};
use r2x_logger as logger;
use std::collections::HashSet;
use std::path::{Path, PathBuf};

/// Find pyproject.toml path by searching common locations
///
/// Searches in order:
/// 1. package_path directory
/// 2. Parent of package_path
/// 3. Parent of discovery_root
/// 4. Grandparent of discovery_root
pub(crate) fn find_pyproject_toml_path(
    package_path: &Path,
    discovery_root: &Path,
) -> Option<PathBuf> {
    let mut seen = HashSet::new();
    let candidates = [
        Some(package_path),
        package_path.parent(),
        discovery_root.parent(),
        discovery_root.parent().and_then(|p| p.parent()),
    ];

    for candidate in candidates.into_iter().flatten() {
        let candidate = candidate.to_path_buf();
        if !seen.insert(candidate.clone()) {
            continue;
        }

        let pyproject = candidate.join("pyproject.toml");
        if pyproject.exists() {
            return Some(pyproject);
        }
    }

    None
}

/// Parse entry points from pyproject.toml content (PEP 621 format)
///
/// Looks for entry points in `[project.entry-points]` table.
pub(crate) fn parse_pyproject_entry_points(content: &str) -> Vec<EntryPointInfo> {
    let mut entries = Vec::new();
    let parsed: toml::Value = match toml::from_str(content) {
        Ok(parsed) => parsed,
        Err(_) => return entries,
    };

    let entry_points = match parsed
        .get("project")
        .and_then(|project| project.get("entry-points"))
        .and_then(|value| value.as_table())
    {
        Some(entry_points) => entry_points,
        None => return entries,
    };

    for (section, values) in entry_points {
        if !is_r2x_section(section) {
            continue;
        }

        let Some(table) = values.as_table() else {
            continue;
        };

        for (name, target) in table {
            let Some(target_str) = target.as_str() else {
                continue;
            };

            let line = format!("{} = {}", name, target_str);
            if let Some(entry) = parse_entry_point_line(&line, section) {
                entries.push(entry);
            }
        }
    }

    if !entries.is_empty() {
        logger::debug(&format!(
            "Parsed {} entry points from pyproject.toml",
            entries.len()
        ));
    }

    entries
}

#[cfg(test)]
mod tests {
    use crate::entry_points::pyproject::*;

    #[test]
    fn test_parse_pyproject_entry_points() {
        let content = r#"
[project]
name = "r2x-reeds"
version = "0.1.0"

[project.entry-points.r2x_plugin]
reeds = "r2x_reeds:ReEDSParser"

[project.entry-points."r2x.transforms"]
add-pcm-defaults = "r2x_reeds.sysmod:add_pcm_defaults"
"#;
        let entries = parse_pyproject_entry_points(content);
        assert_eq!(entries.len(), 2);

        let plugin_entry = entries.iter().find(|e| e.section == "r2x_plugin");
        assert!(plugin_entry.is_some());
        assert!(plugin_entry.is_some_and(|e| e.name == "reeds" && e.symbol == "ReEDSParser"));

        let transform_entry = entries.iter().find(|e| e.section == "r2x.transforms");
        assert!(transform_entry.is_some());
        assert!(transform_entry.is_some_and(|e| e.name == "add-pcm-defaults"));
    }

    #[test]
    fn test_parse_pyproject_entry_points_no_r2x_sections() {
        let content = r#"
[project]
name = "some-package"

[project.entry-points.console_scripts]
cli = "some_package:main"
"#;
        let entries = parse_pyproject_entry_points(content);
        assert!(entries.is_empty());
    }

    #[test]
    fn test_parse_pyproject_entry_points_invalid_toml() {
        let content = "not valid toml {{{";
        let entries = parse_pyproject_entry_points(content);
        assert!(entries.is_empty());
    }
}