lp 0.2.3

An embeddable plugin system for Rust applications.
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

# LibPlugin

![Image](https://github.com/user-attachments/assets/8c401358-3a23-4cea-8c52-368140caf06e)

> An embeddable plugin system for Rust applications.

- LibPlugin handles the majority of boilerplate required for implementing a functional plugin system; offering some flexibility in design & configuration.

***Still under early development; I would recommend against using it for anything serious at the moment.***

- Supported Formats:
    - ***Toml***
    - ***Ron***
    - ***Json***

### Basic Usage
```rust
use lp::{PluginManager, Toml};

fn main() {
    let toml = Toml::parse("plugin_manifest.toml")
        .expect("Failed to parse plugin manifest");

    toml.plugin.register(|plugin| {
        // custom logic to handle registering the plugin
    });

    toml.plugin.run(|plugin| {
        // custom logic to handle executing the plugin
    });

    toml.plugin.unregister(|plugin| {
        // custom logic to handle unregistering the plugin
    });
}
```

### Advanced Usage

```rust

// add to your project: cargo add lp -F dynamic-loading
use lp::{
    PluginManager, Toml,
    load::{Lib, Loadable, Symbol},
};

fn main() {
    let hello_symbol = "hello_fn";
    let toml = Toml::parse("plugin.toml").expect("File not found");
    toml.plugin.register(|plugin| {
        type UnsafeFn = unsafe extern "C" fn() -> *const std::ffi::c_char;

        if let Some(path) = &plugin.path {
            let hello_lib = unsafe {
                Lib::<Symbol<'static, UnsafeFn>>::load(path, hello_symbol)
                    .expect("Failed to load hello function")
            };

            if let Some(hello_fn) = &hello_lib.f {
                let result = unsafe { hello_fn() };
                println!("hello function loaded!");

                println!("{}", unsafe {
                    std::ffi::CStr::from_ptr(result).to_string_lossy()
                });
            }
        }
    });
}
```


### Example: Plugin Manifest

- TOML

```toml
[plugin]
name = "example"
version = "0.1.0"
authors = ["Author Name"]
description = "An example plugin"
license = "MIT"
path = "/path/to/plugin"
```
- RON
```ron
Ron(
    plugin: Plugin(
        name: "example",
        version: "0.1.0",
        authors: Some(["Author Name"]),
        description: Some("An example plugin"),
        license: Some("MIT"),
        path: Some("/path/to/plugin"),
    ),
)
```
- JSON
```json
{
    "plugin": {
        "name": "example",
        "version": "0.1.0",
        "authors": ["Author Name"],
        "description": "An example plugin",
        "license": "MIT",
        "path": "/path/to/plugin"
    }
}
```

#### Roadmap
- Add opt-in support for MCP via [rmcp](https://github.com/modelcontextprotocol/rust-sdk) 

- Enhance Docs