fix(r2x-python): Adding correct python path. (#32)

Author: pesap

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

@@ -63,24 +63,27 @@ impl PluginExtractor {
             debug!("Found {} manifest.add() calls", manifest_add_calls.len());
             let mut plugins = Vec::new();
 
-        for add_match in manifest_add_calls {
-            let add_text = add_match.text();
-            match self.extract_plugin_from_add_call(add_text.as_ref()) {
-                Ok(plugin) => {
-                    debug!("Extracted plugin: {}", plugin.name);
-                    plugins.push(plugin);
-                }
-                Err(err) => {
-                    debug!(
-                        "Failed to parse manifest.add() call '{}': {}",
-                        add_text.lines().next().unwrap_or(""),
-                        err
-                    );
+            for add_match in manifest_add_calls {
+                let add_text = add_match.text();
+                match self.extract_plugin_from_add_call(add_text.as_ref()) {
+                    Ok(plugin) => {
+                        debug!("Extracted plugin: {}", plugin.name);
+                        plugins.push(plugin);
+                    }
+                    Err(err) => {
+                        debug!(
+                            "Failed to parse manifest.add() call '{}': {}",
+                            add_text.lines().next().unwrap_or(""),
+                            err
+                        );
+                    }
                 }
             }
-        }
 
-            info!("Extracted {} plugins from manifest.add() helpers", plugins.len());
+            info!(
+                "Extracted {} plugins from manifest.add() helpers",
+                plugins.len()
+            );
             return Ok(plugins);
         }
 
@@ -99,14 +102,15 @@ impl PluginExtractor {
     }
 
     fn extract_plugin_from_add_call(&self, add_text: &str) -> Result<PluginSpec> {
-        debug!("Parsing PluginSpec from manifest.add(): {}", add_text.lines().next().unwrap_or(""));
+        debug!(
+            "Parsing PluginSpec from manifest.add(): {}",
+            add_text.lines().next().unwrap_or("")
+        );
 
         let sg = AstGrep::new(add_text, Python);
         let root = sg.root();
 
-        let plugin_spec_calls: Vec<_> = root
-            .find_all("PluginSpec.$METHOD($$$ARGS)")
-            .collect();
+        let plugin_spec_calls: Vec<_> = root.find_all("PluginSpec.$METHOD($$$ARGS)").collect();
 
         if plugin_spec_calls.is_empty() {
             return Err(anyhow!("No PluginSpec helper call found in manifest.add()"));
@@ -139,8 +143,7 @@ impl PluginExtractor {
         let entry = self.qualify_symbol(&entry_value);
         let constructor_args = self.resolve_entry_parameters(&entry, &ImplementationType::Class);
 
-        let description =
-            self.find_optional_kwarg_by_role(&kwargs, args::KwArgRole::Description);
+        let description = self.find_optional_kwarg_by_role(&kwargs, args::KwArgRole::Description);
 
         let method_param = self.find_optional_kwarg_by_role(&kwargs, args::KwArgRole::Method);
         let resolved_method = method_param.or_else(|| Self::default_method_for_kind(&kind));
@@ -220,8 +223,7 @@ impl PluginExtractor {
         let method_param = self.find_optional_kwarg_by_role(&kwargs, args::KwArgRole::Method);
         let constructor_args = self.resolve_entry_parameters(&entry, &ImplementationType::Class);
         let kind = self.infer_kind_from_constructor(constructor);
-        let resolved_method =
-            method_param.or_else(|| Self::default_method_for_kind(&kind));
+        let resolved_method = method_param.or_else(|| Self::default_method_for_kind(&kind));
 
         let invocation = InvocationSpec {
             implementation: Self::infer_invocation_type(&entry),
@@ -265,11 +267,7 @@ impl PluginExtractor {
         Ok(self.qualify_symbol(&symbol))
     }
 
-    fn find_kwarg_by_role(
-        &self,
-        kwargs: &[args::KwArg],
-        role: args::KwArgRole,
-    ) -> Result<String> {
+    fn find_kwarg_by_role(&self, kwargs: &[args::KwArg], role: args::KwArgRole) -> Result<String> {
         kwargs
             .iter()
             .find(|kw| kw.role == role)
@@ -313,10 +311,7 @@ impl PluginExtractor {
             ImplementationType::Class => self
                 .extract_class_parameters_from_content(&source, &symbol)
                 .unwrap_or_else(|e| {
-                    debug!(
-                        "Failed to parse constructor for '{}': {}",
-                        entry, e
-                    );
+                    debug!("Failed to parse constructor for '{}': {}", entry, e);
                     Vec::new()
                 }),
             ImplementationType::Function => self

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

@@ -202,10 +202,7 @@ impl PluginExtractor {
                 Some(param_str[colon_idx + 1..].trim()),
             )
         } else if let Some(eq_idx) = param_str.find('=') {
-            (
-                param_str[..eq_idx].trim(),
-                Some(param_str[eq_idx..].trim()),
-            )
+            (param_str[..eq_idx].trim(), Some(param_str[eq_idx..].trim()))
         } else {
             (param_str, None)
         };

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

@@ -155,15 +155,17 @@ manifest.add(PluginSpec.parser(name="demo.parser", entry=DemoParser))
     let plugin_file = pkg_root.join("plugin.py");
     fs::write(&plugin_file, content)?;
 
-    let extractor =
-        PluginExtractor::new(plugin_file, "demo.plugin".to_string(), pkg_root.clone())?;
+    let extractor = PluginExtractor::new(plugin_file, "demo.plugin".to_string(), pkg_root.clone())?;
     let plugins = extractor.extract_plugins()?;
 
     assert_eq!(plugins.len(), 1);
     assert_eq!(plugins[0].name, "demo.parser");
     assert_eq!(plugins[0].entry, "demo.plugin.DemoParser");
     assert_eq!(plugins[0].kind, PluginKind::Parser);
-    assert_eq!(plugins[0].invocation.implementation, ImplementationType::Class);
+    assert_eq!(
+        plugins[0].invocation.implementation,
+        ImplementationType::Class
+    );
     assert!(!plugins[0].invocation.constructor.is_empty());
 
     Ok(())

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

@@ -117,7 +117,10 @@ pub(super) fn build_call_target(bindings: &RuntimeBindings) -> Result<String, Ru
             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)
+                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

@@ -208,40 +208,36 @@ fn run_pipeline(
         logger::debug(&format!("Invoking: {}", target));
         logger::debug(&format!("Config: {}", final_config_json));
 
-        let invocation_result = match bridge.invoke_plugin(
-            &target,
-            &final_config_json,
-            stdin_json,
-            Some(plugin),
-        ) {
-            Ok(inv_result) => {
-                let elapsed = step_start.elapsed();
-                logger::spinner_success(&format!(
-                    "{} [{}/{}] ({})",
-                    plugin_name,
-                    step_num,
-                    total_steps,
-                    super::format_duration(elapsed)
-                ));
-                if logger::get_verbosity() > 0 {
-                    if let Some(timings) = &inv_result.timings {
-                        super::print_plugin_timing_breakdown(timings);
+        let invocation_result =
+            match bridge.invoke_plugin(&target, &final_config_json, stdin_json, Some(plugin)) {
+                Ok(inv_result) => {
+                    let elapsed = step_start.elapsed();
+                    logger::spinner_success(&format!(
+                        "{} [{}/{}] ({})",
+                        plugin_name,
+                        step_num,
+                        total_steps,
+                        super::format_duration(elapsed)
+                    ));
+                    if logger::get_verbosity() > 0 {
+                        if let Some(timings) = &inv_result.timings {
+                            super::print_plugin_timing_breakdown(timings);
+                        }
                     }
+                    inv_result
                 }
-                inv_result
-            }
-            Err(e) => {
-                let elapsed = step_start.elapsed();
-                logger::spinner_error(&format!(
-                    "{} [{}/{}] ({})",
-                    plugin_name,
-                    step_num,
-                    total_steps,
-                    super::format_duration(elapsed)
-                ));
-                return Err(RunError::Bridge(e));
-            }
-        };
+                Err(e) => {
+                    let elapsed = step_start.elapsed();
+                    logger::spinner_error(&format!(
+                        "{} [{}/{}] ({})",
+                        plugin_name,
+                        step_num,
+                        total_steps,
+                        super::format_duration(elapsed)
+                    ));
+                    return Err(RunError::Bridge(e));
+                }
+            };
 
         let result = invocation_result.output;
 
@@ -263,18 +259,18 @@ fn run_pipeline(
         .bold()
     );
 
-        if let Some(final_output) = current_stdin {
-            if let Some(output_path) = output_file {
-                logger::step(&format!("Writing output to: {}", output_path));
-                std::fs::write(output_path, final_output.as_bytes())
-                    .map_err(|e| RunError::Pipeline(PipelineError::Io(e)))?;
-                logger::success(&format!("Output saved to: {}", output_path));
-            } else if opts.suppress_stdout() {
-                logger::debug("Pipeline output suppressed due to -qq");
-            } else {
-                println!("{}", final_output);
-            }
+    if let Some(final_output) = current_stdin {
+        if let Some(output_path) = output_file {
+            logger::step(&format!("Writing output to: {}", output_path));
+            std::fs::write(output_path, final_output.as_bytes())
+                .map_err(|e| RunError::Pipeline(PipelineError::Io(e)))?;
+            logger::success(&format!("Output saved to: {}", output_path));
+        } else if opts.suppress_stdout() {
+            logger::debug("Pipeline output suppressed due to -qq");
+        } else {
+            println!("{}", final_output);
         }
+    }
 
     Ok(())
 }
@@ -337,7 +333,11 @@ fn determine_json_path_field(
         }
     }
 
-    if bindings.entry_parameters.iter().any(|p| p.name == "json_path") {
+    if bindings
+        .entry_parameters
+        .iter()
+        .any(|p| p.name == "json_path")
+    {
         return Some("json_path");
     }
     if bindings.entry_parameters.iter().any(|p| p.name == "path") {
@@ -413,9 +413,9 @@ fn build_plugin_config(
         }
     }
 
-        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 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
@@ -438,7 +438,9 @@ fn build_plugin_config(
             }
         }
 
-        if !config_class_params.is_empty() && bindings.entry_parameters.iter().any(|p| p.name == "config") {
+        if !config_class_params.is_empty()
+            && bindings.entry_parameters.iter().any(|p| p.name == "config")
+        {
             final_config.insert(
                 "config".to_string(),
                 serde_json::Value::Object(config_class_params),
@@ -462,8 +464,11 @@ fn build_plugin_config(
             }
         }
 
-        let needs_store =
-            bindings.requires_store || bindings.entry_parameters.iter().any(|p| p.name == "data_store");
+        let needs_store = bindings.requires_store
+            || bindings
+                .entry_parameters
+                .iter()
+                .any(|p| p.name == "data_store");
 
         if needs_store {
             let store_value = if let serde_json::Value::Object(ref yaml_map) = yaml_config {
@@ -491,7 +496,10 @@ fn build_plugin_config(
             final_config.insert("data_store".to_string(), store_value);
         }
 
-        if bindings.entry_parameters.iter().any(|p| p.name == "folder_path")
+        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 {
@@ -506,14 +514,17 @@ fn build_plugin_config(
 
             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,
-                    })
+                    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()))
+                    inherited_store_path.map(|path| serde_json::Value::String(path.to_string()))
                 });
 
             if let Some(value) = folder_value {

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

@@ -10,10 +10,7 @@ use r2x_python::plugin_invoker::PluginInvocationResult;
 use std::collections::BTreeMap;
 use std::time::Instant;
 
-pub(super) fn handle_plugin_command(
-    cmd: PluginCommand,
-    opts: &GlobalOpts,
-) -> Result<(), RunError> {
+pub(super) fn handle_plugin_command(cmd: PluginCommand, opts: &GlobalOpts) -> Result<(), RunError> {
     match cmd.plugin_name {
         Some(plugin_name) => {
             if cmd.show_help {

crates/r2x-cli/src/help.rs

@@ -83,7 +83,10 @@ pub fn show_plugin_help(plugin_name: &str) -> Result<(), String> {
         println!("  --store-name <NAME>       Name of the store (optional)");
     }
 
-    println!("\nCallable: {}.{}", bindings.entry_module, bindings.entry_name);
+    println!(
+        "\nCallable: {}.{}",
+        bindings.entry_module, bindings.entry_name
+    );
     if let Some(call_method) = &bindings.call_method {
         println!("Method: {}", call_method);
     }
@@ -152,7 +155,6 @@ pub fn show_plugin_help(plugin_name: &str) -> Result<(), String> {
     Ok(())
 }
 
-
 #[cfg(test)]
 mod tests {
     #[test]

crates/r2x-cli/src/lib.rs

@@ -26,6 +26,6 @@ pub use r2x_manifest::errors::ManifestError;
 
 // Re-export manifest types from new module for convenience
 pub use r2x_manifest::{
-    DecoratorRegistration, FunctionParameter, FunctionSignature,
-    Manifest, Metadata, Package, VarArgType,
+    DecoratorRegistration, FunctionParameter, FunctionSignature, Manifest, Metadata, Package,
+    VarArgType,
 };

crates/r2x-cli/src/plugins/discovery.rs

@@ -81,8 +81,7 @@ pub fn discover_and_register_entry_points_with_deps(
     for plugin in &discovered_plugins {
         logger::debug(&format!(
             "Discovered plugin '{}' of kind {:?}",
-            plugin.name,
-            plugin.kind
+            plugin.name, plugin.kind
         ));
     }