fix(r2x): fixed discoverability.

Author: pesap

crates/r2x-ast/src/extractor/mod.rs

@@ -176,7 +176,7 @@ impl PluginExtractor {
 
         for plugin_match in root.find_all("$PLUGIN($$$ARGS)") {
             let env = plugin_match.get_env();
-            let Some(callee) = env.get_match("$PLUGIN") else {
+            let Some(callee) = env.get_match("PLUGIN") else {
                 continue;
             };
             let callee_text = callee.text();

crates/r2x-cli/src/commands/python.rs

@@ -356,6 +356,84 @@ fn handle_python_show(_opts: GlobalOpts) {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::fs;
+    use std::io;
+    use std::path::Path;
+    use tempfile::TempDir;
+
+    struct TestConfigGuard {
+        _dir: TempDir,
+    }
+
+    impl Drop for TestConfigGuard {
+        fn drop(&mut self) {
+            std::env::remove_var("R2X_CONFIG");
+        }
+    }
+
+    fn setup_test_config() -> TestConfigGuard {
+        let dir = TempDir::new().expect("tempdir");
+        let base = dir.path();
+        let config_path = base.join("r2x.toml");
+        let cache_path = base.join("cache");
+        let venv_path = base.join(".venv");
+        let uv_path = if cfg!(windows) {
+            base.join("uv.bat")
+        } else {
+            base.join("uv")
+        };
+
+        fs::create_dir_all(&cache_path).unwrap();
+        fs::create_dir_all(&venv_path).unwrap();
+        create_fake_python(&venv_path).unwrap();
+        write_stub_uv(&uv_path).unwrap();
+
+        let config_contents = format!(
+            "cache_path = \"{}\"\nuv_path = \"{}\"\nvenv_path = \"{}\"\npython_version = \"3.12\"\n",
+            cache_path.to_string_lossy(),
+            uv_path.to_string_lossy(),
+            venv_path.to_string_lossy()
+        );
+
+        fs::write(&config_path, config_contents).unwrap();
+        std::env::set_var("R2X_CONFIG", &config_path);
+
+        TestConfigGuard { _dir: dir }
+    }
+
+    #[cfg(unix)]
+    fn write_stub_uv(path: &Path) -> io::Result<()> {
+        use std::os::unix::fs::PermissionsExt;
+        fs::write(path, "#!/bin/sh\nexit 0\n")?;
+        let mut perms = fs::metadata(path)?.permissions();
+        perms.set_mode(0o755);
+        fs::set_permissions(path, perms)
+    }
+
+    #[cfg(windows)]
+    fn write_stub_uv(path: &Path) -> io::Result<()> {
+        fs::write(path, "@echo off\r\nexit /b 0\r\n")
+    }
+
+    #[cfg(unix)]
+    fn create_fake_python(venv_path: &Path) -> io::Result<()> {
+        use std::os::unix::fs::PermissionsExt;
+        let bin = venv_path.join("bin");
+        fs::create_dir_all(&bin)?;
+        let python = bin.join("python");
+        fs::write(&python, "#!/bin/sh\nexit 0\n")?;
+        let mut perms = fs::metadata(&python)?.permissions();
+        perms.set_mode(0o755);
+        fs::set_permissions(python, perms)
+    }
+
+    #[cfg(windows)]
+    fn create_fake_python(venv_path: &Path) -> io::Result<()> {
+        let scripts = venv_path.join("Scripts");
+        fs::create_dir_all(&scripts)?;
+        fs::write(scripts.join("python.exe"), [])?;
+        Ok(())
+    }
 
     fn normal_opts() -> GlobalOpts {
         GlobalOpts {
@@ -367,6 +445,7 @@ mod tests {
 
     #[test]
     fn test_python_install() {
+        let _guard = setup_test_config();
         handle_python(
             PythonAction::Install {
                 version: Some("3.12".to_string()),
@@ -377,35 +456,49 @@ mod tests {
 
     #[test]
     fn test_python_install_no_version() {
+        let _guard = setup_test_config();
         handle_python(PythonAction::Install { version: None }, normal_opts());
     }
 
     #[test]
     fn test_python_path() {
+        let _guard = setup_test_config();
         handle_python(PythonAction::Path, normal_opts());
     }
 
     #[test]
     fn test_python_show() {
+        let _guard = setup_test_config();
         handle_python(PythonAction::Show, normal_opts());
     }
 
     #[test]
     fn test_venv_create() {
+        let _guard = setup_test_config();
         handle_venv(None, false, normal_opts());
     }
 
     #[test]
     fn test_venv_create_skip_confirm() {
+        let _guard = setup_test_config();
         handle_venv(None, true, normal_opts());
     }
 
     #[test]
     fn test_venv_path() {
+        let _guard = setup_test_config();
         handle_venv(
             Some(VenvAction::Path { new_path: None }),
             false,
             normal_opts(),
         );
     }
+
+    #[test]
+    fn test_venv_create_yes_flag() {
+        let _guard = setup_test_config();
+        std::env::set_var("R2X_VENV_YES", "1");
+        handle_venv(None, false, normal_opts());
+        std::env::remove_var("R2X_VENV_YES");
+    }
 }

crates/r2x-cli/src/commands/run/mod.rs

@@ -5,7 +5,7 @@ use crate::GlobalOpts;
 use clap::Parser;
 use pipeline::handle_pipeline_mode;
 use plugin::handle_plugin_command;
-use r2x_manifest::runtime::RuntimeBindings;
+use r2x_manifest::{runtime::RuntimeBindings, PluginKind};
 use r2x_python::plugin_invoker::PluginInvocationTimings;
 use std::time::Duration;
 
@@ -114,7 +114,9 @@ pub fn handle_run(cmd: RunCommand, opts: GlobalOpts) -> Result<(), RunError> {
 pub(super) fn build_call_target(bindings: &RuntimeBindings) -> Result<String, RunError> {
     let target = match bindings.implementation_type {
         r2x_manifest::ImplementationType::Class => {
-            if let Some(call_method) = &bindings.call_method {
+            if bindings.plugin_kind == PluginKind::Upgrader {
+                format!("{}:{}", bindings.entry_module, bindings.entry_name)
+            } else if let Some(call_method) = &bindings.call_method {
                 format!("{}:{}.{}", bindings.entry_module, bindings.entry_name, call_method)
             } else {
                 format!("{}:{}", bindings.entry_module, bindings.entry_name)

crates/r2x-cli/src/commands/run/pipeline.rs

@@ -413,8 +413,9 @@ fn build_plugin_config(
         }
     }
 
-    let mut final_config = serde_json::Map::new();
-    if bindings.implementation_type == r2x_manifest::ImplementationType::Class {
+        let mut final_config = serde_json::Map::new();
+        let mut store_value_for_folder: Option<serde_json::Value> = None;
+        if bindings.implementation_type == r2x_manifest::ImplementationType::Class {
         let mut config_class_params = serde_json::Map::new();
         let mut constructor_params = serde_json::Map::new();
         let config_param_names: HashSet<String> = bindings
@@ -486,8 +487,39 @@ fn build_plugin_config(
                 }
             };
 
+            store_value_for_folder = Some(store_value.clone());
             final_config.insert("data_store".to_string(), store_value);
         }
+
+        if bindings.entry_parameters.iter().any(|p| p.name == "folder_path")
+            && !final_config.contains_key("folder_path")
+        {
+            let explicit_folder = if let serde_json::Value::Object(ref yaml_map) = yaml_config {
+                yaml_map
+                    .get("folder_path")
+                    .or_else(|| yaml_map.get("store_path"))
+                    .or_else(|| yaml_map.get("path"))
+                    .cloned()
+            } else {
+                None
+            };
+
+            let folder_value = explicit_folder
+                .or_else(|| {
+                    store_value_for_folder.as_ref().and_then(|value| match value {
+                        serde_json::Value::String(s) => Some(serde_json::Value::String(s.clone())),
+                        _ => None,
+                    })
+                })
+                .or_else(|| {
+                    inherited_store_path
+                        .map(|path| serde_json::Value::String(path.to_string()))
+                });
+
+            if let Some(value) = folder_value {
+                final_config.insert("folder_path".to_string(), value);
+            }
+        }
     } else if let serde_json::Value::Object(ref yaml_map) = yaml_config {
         final_config.extend(yaml_map.clone());
     }

crates/r2x-cli/tests/fixtures/r2x.toml

@@ -1,2 +1,3 @@
 cache_path = "/tmp/r2x-cache"
 uv_path = "/Users/psanchez/.local/bin/uv"
+python_version = "3.12"