plugins: drop dead code

Whatever I had in mind, is not going to work.

Author: NotAShelf

src/interface.rs

@@ -563,59 +563,44 @@ fn run_plugin_function(
     args: Vec<String>,
 ) -> Result<()> {
     // Get plugin instance from manager
-    let plugin_meta = pm
-        .get_plugin(plugin_name)
+    let plugin = pm
+        .get_plugin_instance(plugin_name)
         .ok_or_else(|| color_eyre::eyre::eyre!("Plugin not found: {}", plugin_name))?;
 
+    // Check if the function exists
+    if !plugin.has_function(function_name) {
+        return Err(color_eyre::eyre::eyre!(
+            "Function '{}' not found in plugin '{}'",
+            function_name,
+            plugin_name
+        ));
+    }
+
     // Create Lua values from the arguments
-    let lua = pm.lua();
+    let lua = plugin.get_lua();
     let lua_args = args
         .iter()
         .map(|arg| mlua::Value::String(lua.create_string(arg).unwrap()))
         .collect::<Vec<_>>();
 
-    // Get the plugin table and check if the function exists
-    let plugin_table = lua
-        .globals()
-        .get::<mlua::Table>(&*plugin_meta.name)
-        .map_err(|e| color_eyre::eyre::eyre!("Error accessing plugin table: {}", e))?;
-
-    if plugin_table
-        .contains_key(function_name)
-        .map_err(|e| color_eyre::eyre::eyre!("Error checking function existence: {}", e))?
-    {
-        let function = plugin_table
-            .get::<mlua::Function>(function_name)
-            .map_err(|e| color_eyre::eyre::eyre!("Error getting function: {}", e))?;
-
-        // Call the function with proper arguments
-        let args_multi = mlua::MultiValue::from_vec(lua_args);
-        let result = function
-            .call(args_multi)
-            .map_err(|e| color_eyre::eyre::eyre!("Error executing plugin function: {}", e))?;
-
-        // Print the result
-        match result {
-            mlua::Value::Nil => println!("Function executed successfully (no result)"),
-            mlua::Value::Boolean(b) => println!("Result: {}", b),
-            mlua::Value::Integer(i) => println!("Result: {}", i),
-            mlua::Value::Number(n) => println!("Result: {}", n),
-            mlua::Value::String(s) => println!(
-                "Result: {}",
-                s.to_str()
-                    .map_err(|e| color_eyre::eyre::eyre!("Error converting string: {}", e))?
-            ),
-            mlua::Value::Table(_) => println!("Result: [table]"),
-            mlua::Value::Function(_) => println!("Result: [function]"),
-            _ => println!("Result: [other]"),
-        }
-
-        Ok(())
-    } else {
-        Err(color_eyre::eyre::eyre!(
-            "Function '{}' not found in plugin '{}'",
-            function_name,
-            plugin_name
-        ))
+    // Execute the function with the args
+    let result = plugin.execute_function(function_name, lua_args)?;
+
+    // Print the result
+    match result {
+        mlua::Value::Nil => println!("Function executed successfully (no result)"),
+        mlua::Value::Boolean(b) => println!("Result: {}", b),
+        mlua::Value::Integer(i) => println!("Result: {}", i),
+        mlua::Value::Number(n) => println!("Result: {}", n),
+        mlua::Value::String(s) => println!(
+            "Result: {}",
+            s.to_str()
+                .map_err(|e| color_eyre::eyre::eyre!("Error converting string: {}", e))?
+        ),
+        mlua::Value::Table(_) => println!("Result: [table]"),
+        mlua::Value::Function(_) => println!("Result: [function]"),
+        _ => println!("Result: [other]"),
     }
+
+    Ok(())
 }

src/plugins/config.rs

@@ -64,8 +64,6 @@ impl PluginConfig {
 
     /// Save plugin configuration to disk
     pub fn save(&self) -> Result<()> {
-        let config_paths = Self::get_config_paths();
-
         // Try to save to the first config path that's writable
         if let Some(config_dir) = dirs::config_dir() {
             let config_file = config_dir.join("nh").join("plugins.toml");

src/plugins/manager.rs

@@ -2,7 +2,8 @@
 
 use std::collections::HashMap;
 use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex};
+use std::rc::Rc;
+use std::sync::Mutex;
 
 use color_eyre::eyre::{bail, eyre};
 use mlua::Lua;
@@ -18,7 +19,7 @@ use crate::Result;
 #[derive(Debug)]
 pub struct PluginManager {
     /// Lua state
-    lua: Arc<Lua>,
+    lua: Rc<Lua>,
     /// Loaded plugins
     plugins: Mutex<HashMap<String, Plugin>>,
     /// Plugin hooks
@@ -37,7 +38,7 @@ impl PluginManager {
         let config = PluginConfig::load()?;
 
         Ok(Self {
-            lua: Arc::new(lua),
+            lua: Rc::new(lua),
             plugins: Mutex::new(HashMap::new()),
             hooks,
             config,
@@ -163,7 +164,7 @@ impl PluginManager {
         let plugin = Plugin::new(
             name.to_string(),
             path.to_path_buf(),
-            Arc::clone(&self.lua),
+            Rc::clone(&self.lua),
             &self.hooks,
         )?;
 
@@ -196,6 +197,12 @@ impl PluginManager {
         plugins.get(name).map(|p| p.get_metadata().clone())
     }
 
+    /// Get a direct reference to a plugin by name
+    pub fn get_plugin_instance(&self, name: &str) -> Option<Plugin> {
+        let plugins = self.plugins.lock().unwrap();
+        plugins.get(name).cloned()
+    }
+
     /// Reload a specific plugin
     pub fn reload_plugin(&self, name: &str) -> Result<()> {
         let mut plugins = self.plugins.lock().unwrap();

src/plugins/plugin.rs

@@ -1,6 +1,6 @@
 use std::fs;
 use std::path::{Path, PathBuf};
-use std::sync::Arc;
+use std::rc::Rc;
 
 use color_eyre::eyre::{eyre, Context};
 use mlua::{Function, Lua, Table};
@@ -15,15 +15,15 @@ pub struct Plugin {
     /// Plugin metadata
     pub metadata: PluginMetadata,
     /// Lua state reference
-    lua: Arc<Lua>,
+    lua: Rc<Lua>,
 }
 
 impl Plugin {
     /// Create a new plugin instance
     pub fn new(
         name: String,
         path: PathBuf,
-        lua: Arc<Lua>,
+        lua: Rc<Lua>,
         hook_manager: &HookManager,
     ) -> Result<Self> {
         let code = fs::read_to_string(&path)
@@ -220,7 +220,7 @@ impl Plugin {
     }
 
     /// Get the Lua state reference
-    pub const fn get_lua(&self) -> &Arc<Lua> {
+    pub const fn get_lua(&self) -> &Rc<Lua> {
         &self.lua
     }
 
@@ -232,7 +232,7 @@ impl Plugin {
         info!("Reloading plugin: {}", name);
 
         // Create a new instance with the same name and path
-        let new_plugin = Self::new(name, path, Arc::clone(&self.lua), hook_manager)?;
+        let new_plugin = Self::new(name, path, Rc::clone(&self.lua), hook_manager)?;
 
         // Update this instance with the new plugin's data
         self.metadata = new_plugin.metadata;

src/plugins/types.rs

@@ -1,7 +1,7 @@
 use std::fmt;
 use std::path::PathBuf;
 
-use mlua::{Lua, Table, Value};
+use mlua::{Lua, Table};
 
 /// Plugin metadata
 #[derive(Debug, Clone)]
@@ -137,9 +137,7 @@ pub enum PluginResult {
 }
 
 /// Plugin execution context
-pub struct PluginContext<'lua> {
-    /// Lua state
-    pub lua: &'lua Lua,
+pub struct PluginContext {
     /// Command being executed
     pub command: Option<String>,
     /// Arguments for the command
@@ -150,28 +148,10 @@ pub struct PluginContext<'lua> {
     pub category: CommandCategory,
 }
 
-impl<'lua> PluginContext<'lua> {
-    /// Create a new plugin context
-    pub fn new(lua: &'lua Lua, command: Option<String>, args: Vec<String>) -> Self {
-        let data = lua
-            .create_table()
-            .expect("Failed to create context data table");
-
-        // By default, treat commands as user commands
-        let category = CommandCategory::User;
-
-        Self {
-            lua,
-            command,
-            args,
-            data,
-            category,
-        }
-    }
-
+impl PluginContext {
     /// Create a new plugin context with specified category
     pub fn with_category(
-        lua: &'lua Lua,
+        lua: &Lua,
         command: Option<String>,
         args: Vec<String>,
         category: CommandCategory,
@@ -181,59 +161,10 @@ impl<'lua> PluginContext<'lua> {
             .expect("Failed to create context data table");
 
         Self {
-            lua,
             command,
             args,
             data,
             category,
         }
     }
-
-    /// Add a value to the context data
-    pub fn add_data(&self, key: &str, value: Value) -> mlua::Result<()> {
-        self.data.set(key, value)
-    }
-
-    /// Get a value from the context data
-    pub fn get_data<T: mlua::FromLua>(&self, key: &str) -> mlua::Result<T> {
-        self.data.get(key)
-    }
-
-    /// Convert the context to a Lua table
-    pub fn to_lua_table(&self) -> mlua::Result<Table> {
-        let ctx_table = self.lua.create_table()?;
-
-        // Set command if available
-        if let Some(cmd) = &self.command {
-            ctx_table.set("command", cmd.clone())?;
-        } else {
-            ctx_table.set("command", mlua::Nil)?;
-        }
-
-        // Set arguments
-        let args_table = self.lua.create_table()?;
-        for (i, arg) in self.args.iter().enumerate() {
-            args_table.set(i + 1, arg.clone())?;
-        }
-        ctx_table.set("args", args_table)?;
-
-        // Set data
-        ctx_table.set("data", self.data.clone())?;
-
-        // Set category
-        let category_str = match self.category {
-            CommandCategory::User => "user",
-            CommandCategory::System => "system",
-            CommandCategory::Plugin => "plugin",
-            CommandCategory::Any => "any",
-        };
-        ctx_table.set("category", category_str)?;
-
-        Ok(ctx_table)
-    }
-
-    /// Execute Lua code in this context
-    pub fn execute_lua(&self, code: &str) -> mlua::Result<Value> {
-        self.lua.load(code).eval()
-    }
 }