diff --git a/docs/CURRENT_TASK.md b/docs/CURRENT_TASK.md index 58ec156a..32a578e5 100644 --- a/docs/CURRENT_TASK.md +++ b/docs/CURRENT_TASK.md @@ -144,25 +144,39 @@ read = { - [phase_8_6_vm_performance_improvement.md](../予定/native-plan/issues/phase_8_6_vm_performance_improvement.md) - 詳細技術分析 - [copilot_issues.txt](../予定/native-plan/copilot_issues.txt) - 全体開発計画 -## 🔧 **現在進行中：ビルトインBoxプラグイン化プロジェクト**（2025-08-18開始） +## 🔧 **現在進行中：マルチBox型プラグイン対応**（2025-08-18開始） ### **目的** +- **依存関係の解決**: HTTPServerBoxとSocketBoxを同一プラグインに +- **効率的な配布**: 関連Box群を1つのライブラリで提供 - **ビルド時間短縮**: 3分 → 30秒以下 -- **バイナリサイズ削減**: 最小構成で500KB以下 -- **保守性向上**: 各プラグイン独立開発 -### **対象Box（13種類）** -``` -Phase 1: ネットワーク系（HttpBox系、SocketBox） -Phase 2: GUI系（EguiBox、Canvas系、Web系） -Phase 3: 特殊用途系（AudioBox、QRBox、StreamBox等） +### **nyash.toml v2設計** +```toml +[plugins.libraries] +"nyash-network" = { + plugin_path = "libnyash_network.so", + provides = ["SocketBox", "HTTPServerBox", "HTTPRequestBox", "HTTPResponseBox", "HttpClientBox"] +} ``` +### **実装フェーズ** +1. **Phase 1**: plugin-tester拡張（進行中） + - 複数Box型の検出機能 + - 各Box型のメソッド検証 + +2. **Phase 2**: テストプラグイン作成 + - 簡単な複数Box型プラグイン + - FFI実装確認 + +3. **Phase 3**: Nyash本体対応 + - nyash.toml v2パーサー + - マルチBox型ローダー + ### **進捗状況** -- ✅ プラグイン移行依頼書作成（`docs/plugin-migration-request.md`） -- ✅ CopilotのBID変換コード抽出（`src/bid-converter-copilot/`） -- ✅ CopilotのBIDコード生成機能抽出（`src/bid-codegen-from-copilot/`） -- 🔄 HttpBoxプラグイン化作業をCopilotに依頼中 +- ✅ nyash.toml v2仕様策定完了 +- ✅ plugin-system.mdドキュメント更新 +- 🔄 plugin-tester拡張作業開始 ## 📋 **今日の重要決定事項（2025年8月18日）** @@ -192,11 +206,12 @@ Phase 3: 特殊用途系（AudioBox、QRBox、StreamBox等） --- **最終更新**: 2025年8月18日 -**次回レビュー**: HttpBoxプラグイン完成時 -**開発状況**: ビルトインBoxプラグイン化進行中 +**次回レビュー**: マルチBox型プラグイン対応完了時 +**開発状況**: nyash.toml v2（マルチBox型）対応開始 ### 🎯 **次のアクション** -1. HttpBoxプラグイン化の完成待ち（Copilot作業中） -2. plugin-testerでの動作確認 -3. 次のプラグイン化対象（EguiBox等）の準備 +1. plugin-testerを複数Box型対応に拡張 +2. 簡単な複数Box型プラグインのテスト作成 +3. Nyash本体のローダーを複数Box型対応に拡張 +4. 複数Box型の読み込みテスト実施 diff --git a/docs/nyash-toml-v2-spec.md b/docs/nyash-toml-v2-spec.md new file mode 100644 index 00000000..36d9184e --- /dev/null +++ b/docs/nyash-toml-v2-spec.md @@ -0,0 +1,107 @@ +# nyash.toml v2 仕様 - マルチBox型プラグイン対応 + +## 🎯 概要 +1つのプラグインライブラリが複数のBox型を提供できるように拡張した仕様。 + +## 📝 基本構造 + +### 1. 後方互換性のある現行形式（単一Box型） +```toml +[plugins] +FileBox = "nyash-filebox-plugin" + +[plugins.FileBox.methods] +read = { args = [] } +write = { args = [{ from = "string", to = "bytes" }] } +``` + +### 2. 新形式：マルチBox型プラグイン +```toml +# ライブラリ定義 +[plugins.libraries] +"nyash-network" = { + plugin_path = "libnyash_network.so", + provides = ["SocketBox", "HTTPServerBox", "HTTPRequestBox", "HTTPResponseBox"] +} + +# 各Box型の詳細定義 +[plugins.types.SocketBox] +library = "nyash-network" +type_id = 100 +methods = { + bind = { args = [ + { name = "address", from = "string", to = "string" }, + { name = "port", from = "integer", to = "u16" } + ]} +} + +[plugins.types.HTTPServerBox] +library = "nyash-network" +type_id = 101 +methods = { + bind = { args = [ + { name = "address", from = "string", to = "string" }, + { name = "port", from = "integer", to = "u16" } + ]}, + route = { args = [ + { name = "path", from = "string", to = "string" }, + { name = "handler", from = "box", to = "box" } + ]} +} +``` + +## 🔧 型システム + +### サポートする型（基本型のみ） +```toml +{ from = "string", to = "string" } # 文字列 +{ from = "integer", to = "i64" } # 整数 +{ from = "float", to = "f64" } # 浮動小数点 +{ from = "bool", to = "bool" } # 真偽値 +{ from = "bytes", to = "bytes" } # バイト配列 +``` + +**重要**: プラグインとNyash本体間では基本型のみやり取り。Box型の受け渡しは行わない（箱は箱で完結）。 + +### 2. プラグインFFI拡張 +```c +// 既存: 単一Box型 +nyash_plugin_abi_version() +nyash_plugin_init() + +// 新規: 複数Box型 +nyash_plugin_get_box_count() // 提供するBox型の数 +nyash_plugin_get_box_info(index) // 各Box型の情報 +``` + +## 📊 実装優先順位 + +1. **Phase 1**: nyash.toml v2パーサー実装 + - 後方互換性維持 + - 新形式の読み込み + +2. **Phase 2**: plugin-tester拡張 + - 複数Box型の検出 + - 各Box型のメソッド検証 + +3. **Phase 3**: ローダー拡張 + - 複数Box型の登録 + - 型ID管理 + +## 🎯 HTTPServerBox依存問題の解決 + +この設計により、以下が可能になります： + +```toml +[plugins.libraries] +"nyash-network" = { + plugin_path = "libnyash_network.so", + provides = ["SocketBox", "HTTPServerBox", "HTTPRequestBox", "HTTPResponseBox"] +} + +# HTTPServerBoxはプラグイン内でSocketBoxを直接使用可能 +# MapBoxへの依存は以下のように解決： +# - HTTPResponseBoxは内部でHashMapを使用 +# - get_header("name") で個別アクセス +# - get_all_headers() は文字列配列として返す +``` \ No newline at end of file diff --git a/docs/説明書/reference/plugin-system/plugin-system.md b/docs/説明書/reference/plugin-system/plugin-system.md index 217a228f..59b435ed 100644 --- a/docs/説明書/reference/plugin-system/plugin-system.md +++ b/docs/説明書/reference/plugin-system/plugin-system.md @@ -65,32 +65,158 @@ lifecycle: ## 🔧 設定ファイル（nyash.toml） +### 基本形式（v1） - 単一Box型プラグイン + ```toml # プロジェクトルートのnyash.toml [plugins] -FileBox = "filebox" # FileBoxはプラグイン版を使用 -# StringBox = "mystring" # コメントアウト = ビルトイン使用 +FileBox = "nyash-filebox-plugin" # FileBoxはプラグイン版を使用 +# StringBox = "mystring" # コメントアウト = ビルトイン使用 + +# FileBoxの型情報定義 +[plugins.FileBox.methods] +read = { args = [] } +write = { args = [{ from = "string", to = "bytes" }] } +open = { args = [ + { name = "path", from = "string", to = "string" }, + { name = "mode", from = "string", to = "string" } +] } +close = { args = [] } +exists = { args = [], returns = "bool" } +``` + +### 拡張形式（v2） - マルチBox型プラグイン + +```toml +# 1つのプラグインで複数のBox型を提供 +[plugins.libraries] +"nyash-network" = { + plugin_path = "libnyash_network.so", + provides = ["SocketBox", "HTTPServerBox", "HTTPRequestBox", "HTTPResponseBox", "HttpClientBox"] +} + +"nyash-stdlib" = { + plugin_path = "libnyash_stdlib.so", + provides = ["MathBox", "TimeBox", "RandomBox"] +} + +# 各Box型の詳細定義 +[plugins.types.SocketBox] +library = "nyash-network" +type_id = 100 +methods = { + bind = { args = [ + { name = "address", from = "string", to = "string" }, + { name = "port", from = "integer", to = "u16" } + ]}, + connect = { args = [ + { name = "address", from = "string", to = "string" }, + { name = "port", from = "integer", to = "u16" } + ]}, + read = { args = [], returns = "string" }, + write = { args = [{ from = "string", to = "bytes" }] }, + close = { args = [] } +} + +[plugins.types.HTTPServerBox] +library = "nyash-network" +type_id = 101 +methods = { + bind = { args = [ + { name = "address", from = "string", to = "string" }, + { name = "port", from = "integer", to = "u16" } + ]}, + route = { args = [ + { name = "path", from = "string", to = "string" }, + { name = "method", from = "string", to = "string" } + ]}, + start = { args = [] } +} + +[plugins.types.HttpClientBox] +library = "nyash-network" +type_id = 102 +methods = { + get = { args = [{ name = "url", from = "string", to = "string" }], returns = "string" }, + post = { args = [ + { name = "url", from = "string", to = "string" }, + { name = "body", from = "string", to = "string" } + ], returns = "string" } +} +``` + +### 型マッピング仕様 + +#### 基本型 +| Nyash型 | FFI型 | TLVタグ | 説明 | +|---------|-------|---------|------| +| `string` | `string` | 0x01 | UTF-8文字列 | +| `integer` | `i64` | 0x02 | 64ビット整数 | +| `float` | `f64` | 0x03 | 64ビット浮動小数点 | +| `bool` | `bool` | 0x04 | 真偽値 | +| `bytes` | `Vec` | 0x05 | バイト配列 | + + +### プラグイン検索パス + +```toml +[plugin_paths] +search_paths = [ + "./plugins/*/target/release", # 開発時リリースビルド + "./plugins/*/target/debug", # 開発時デバッグビルド + "/usr/local/lib/nyash/plugins", # システムインストール + "~/.nyash/plugins" # ユーザーローカル +] ``` ## 🏗️ アーキテクチャ -### 1. Boxレジストリ +### 1. Boxレジストリ（v2対応版） ```rust // 起動時の動作 let mut registry = HashMap::new(); +let mut loaded_plugins = HashMap::new(); // 1. ビルトインBoxを登録 registry.insert("FileBox", BoxProvider::Builtin(native_filebox)); registry.insert("StringBox", BoxProvider::Builtin(native_stringbox)); // 2. nyash.toml読み込み -let config = parse_nyash_toml()?; +let config = parse_nyash_toml_v2()?; -// 3. プラグイン設定で上書き +// 3a. v1形式：単一Box型プラグイン for (box_name, plugin_name) in config.plugins { registry.insert(box_name, BoxProvider::Plugin(plugin_name)); } + +// 3b. v2形式：マルチBox型プラグイン +if let Some(libraries) = config.libraries { + for (lib_name, lib_def) in libraries.libraries { + // プラグインを一度だけロード + let plugin = load_plugin(&lib_def.plugin_path)?; + loaded_plugins.insert(lib_name.clone(), plugin); + + // 提供する全Box型を登録 + for box_type in &lib_def.provides { + registry.insert(box_type, BoxProvider::MultiPlugin(lib_name.clone())); + } + } +} +``` + +### マルチBox型プラグインFFI + +```c +// v2プラグインの追加エクスポート関数 +// 提供するBox型の数を返す +extern "C" u32 nyash_plugin_get_box_count(); + +// 各Box型の情報を取得 +extern "C" NyashPluginInfo* nyash_plugin_get_box_info(u32 index); + +// Box型名からtype_idを解決 +extern "C" u32 nyash_plugin_get_type_id(const char* box_name); ``` ### 2. 透過的なディスパッチ @@ -232,30 +358,68 @@ impl Drop for PluginBox { ## 🚀 段階的導入計画 -### Phase 1: 基本実装（現在） +### Phase 1: 基本実装（完了） - [x] BID-FFI基盤 - [x] FileBoxプラグイン実装 -- [ ] nyash.tomlパーサー -- [ ] PluginBoxプロキシ -- [ ] 手動プラグインロード +- [x] nyash.toml v1パーサー +- [x] PluginBoxプロキシ +- [x] プラグインロード機能 -### Phase 2: 開発体験向上 +### Phase 2: マルチBox型対応（進行中） +- [ ] nyash.toml v2パーサー実装 +- [ ] マルチBox型プラグインFFI拡張 +- [ ] plugin-testerの複数Box型対応 +- [ ] ネットワーク系プラグイン統合 + - HttpClientBox（新規実装） + - SocketBox（既存移行） + - HTTPServerBox（既存移行） + - HTTPRequestBox（既存移行） + - HTTPResponseBox（既存移行） + +### Phase 3: 開発体験向上 - [ ] YAMLからFFIコード自動生成 - [ ] エラーメッセージ改善 - [ ] プラグインテンプレート +- [ ] ホットリロード対応 -### Phase 3: エコシステム +### Phase 4: エコシステム - [ ] プラグインレジストリ - [ ] バージョン管理 - [ ] 依存関係解決 +- [ ] プラグイン間通信 ## 🎉 利点 +### v1形式の利点 1. **ビルド時間短縮** - 使わないBoxはコンパイル不要 2. **動的拡張** - 再コンパイルなしで新Box追加 3. **Everything is Box維持** - 哲学は変わらない 4. **段階的移行** - 1つずつBoxをプラグイン化 +### v2形式の追加利点 +5. **依存関係の解決** - 関連Box群を1つのプラグインに +6. **効率的な配布** - 複数Box型を1ライブラリで提供 +7. **メモリ効率** - 共有ライブラリは1度だけロード +8. **内部連携** - 同一プラグイン内で直接通信可能 + +### 実例：HTTPServerBoxの依存問題解決 + +```toml +# v1では困難だった構成 +# HTTPServerBoxはSocketBoxに依存するが... +[plugins] +SocketBox = "socket-plugin" # 別プラグイン +HTTPServerBox = "http-plugin" # SocketBoxが使えない！ + +# v2なら簡単に解決 +[plugins.libraries] +"nyash-network" = { + plugin_path = "libnyash_network.so", + provides = ["SocketBox", "HTTPServerBox", "HTTPRequestBox", "HTTPResponseBox"] +} +# HTTPServerBoxは同じプラグイン内でSocketBoxを直接使用可能 +``` + ## 📚 関連ドキュメント - [BID-FFI仕様](./ffi-abi-specification.md) diff --git a/local_tests/test_http_minimal.nyash b/local_tests/test_http_minimal.nyash new file mode 100644 index 00000000..23cf1884 --- /dev/null +++ b/local_tests/test_http_minimal.nyash @@ -0,0 +1,14 @@ +// HttpClientBox最小テスト +static box Main { + init { http } + + main() { + me.http = new HttpClientBox() + + // GET test + local result = me.http.get("https://httpbin.org/get") + print(result) + + return "done" + } +} \ No newline at end of file diff --git a/local_tests/test_http_server.nyash b/local_tests/test_http_server.nyash new file mode 100644 index 00000000..ea00709a --- /dev/null +++ b/local_tests/test_http_server.nyash @@ -0,0 +1,33 @@ +// 🌐 HTTPServerBox簡単テスト +static box Main { + init { server, console } + + main() { + me.console = new ConsoleBox() + me.console.log("🚀 HTTPサーバーテスト開始...") + + // HTTPServerBoxを作成 + me.server = new HTTPServerBox() + + // サーバー設定 + me.server.port(8080) + + // ルートハンドラー設定 + me.server.route("/", "GET", function(request) { + return "Welcome to Nyash HTTP Server!" + }) + + // JSONレスポンス + me.server.route("/api/hello", "GET", function(request) { + local response = new MapBox() + response.set("message", "Hello from Nyash!") + response.set("timestamp", new TimeBox().now()) + return response + }) + + me.console.log("🌍 サーバー起動: http://localhost:8080") + me.server.start() + + return "サーバー実行中..." + } +} \ No newline at end of file diff --git a/local_tests/test_http_server_working.nyash b/local_tests/test_http_server_working.nyash new file mode 100644 index 00000000..24dd554f --- /dev/null +++ b/local_tests/test_http_server_working.nyash @@ -0,0 +1,25 @@ +// HTTPServerBoxの動作テスト +static box Main { + init { + ConsoleBox console, + HTTPServerBox server + } + + main() { + me.console = new ConsoleBox() + me.console.log("🌐 HTTPServerBoxテスト開始...") + + // HTTPServerBoxを作成 + me.server = new HTTPServerBox() + me.console.log("✅ HTTPServerBox作成成功") + + // 基本情報を表示 + me.console.log("HTTPServerBox: " + me.server.toString()) + + // bind設定（実際のサーバー起動はしない） + me.server.bind("127.0.0.1", 8080) + me.console.log("✅ Bind設定完了: 127.0.0.1:8080") + + return "完了" + } +} \ No newline at end of file diff --git a/local_tests/test_http_simple.nyash b/local_tests/test_http_simple.nyash new file mode 100644 index 00000000..2d8cb7ce --- /dev/null +++ b/local_tests/test_http_simple.nyash @@ -0,0 +1,28 @@ +// 🌐 HttpClientBox簡単テスト +static box Main { + init { http, console } + + main() { + me.console = new ConsoleBox() + me.console.log("🌐 HTTP通信テスト開始...") + + // HttpClientBoxを作成 + me.http = new HttpClientBox() + + // 1. 簡単なGETリクエスト + me.console.log("📥 GET: https://httpbin.org/get") + local getResult = me.http.get("https://httpbin.org/get") + me.console.log("結果: " + getResult.toString()) + + // 2. POSTリクエスト + me.console.log("") + me.console.log("📤 POST: https://httpbin.org/post") + local postResult = me.http.post( + "https://httpbin.org/post", + "Hello from Nyash!" + ) + me.console.log("結果: " + postResult.toString()) + + return "✅ HTTPテスト完了" + } +} \ No newline at end of file diff --git a/local_tests/test_socket_echo.nyash b/local_tests/test_socket_echo.nyash new file mode 100644 index 00000000..acebe715 --- /dev/null +++ b/local_tests/test_socket_echo.nyash @@ -0,0 +1,22 @@ +// 🔌 SocketBox簡単テスト（TCP通信） +static box Main { + init { console } + + main() { + me.console = new ConsoleBox() + me.console.log("🔌 TCP通信テスト...") + + // シンプルなTCPクライアント + local socket = new SocketBox() + + // Google DNSに接続してテスト + socket.connect("8.8.8.8", 53) + me.console.log("✅ 接続成功: 8.8.8.8:53") + + // 切断 + socket.close() + me.console.log("✅ 切断完了") + + return "ソケットテスト完了" + } +} \ No newline at end of file diff --git a/local_tests/test_socket_working.nyash b/local_tests/test_socket_working.nyash new file mode 100644 index 00000000..201b7078 --- /dev/null +++ b/local_tests/test_socket_working.nyash @@ -0,0 +1,21 @@ +// SocketBoxの動作テスト +static box Main { + init { + ConsoleBox console, + SocketBox socket + } + + main() { + me.console = new ConsoleBox() + me.console.log("🔌 SocketBoxテスト開始...") + + // SocketBoxを作成 + me.socket = new SocketBox() + me.console.log("✅ SocketBox作成成功") + + // 基本情報を表示 + me.console.log("SocketBox: " + me.socket.toString()) + + return "完了" + } +} \ No newline at end of file diff --git a/local_tests/test_working_boxes.nyash b/local_tests/test_working_boxes.nyash new file mode 100644 index 00000000..ab107080 --- /dev/null +++ b/local_tests/test_working_boxes.nyash @@ -0,0 +1,42 @@ +// 動作するBox型のテスト +static box Main { + init { + StringBox console, + IntegerBox count, + ArrayBox list, + MapBox data + } + + main() { + // ConsoleBoxで出力 + me.console = new ConsoleBox() + me.console.log("🎉 動作するBoxのテスト開始！") + + // StringBox + local text = new StringBox("Hello Nyash!") + me.console.log("StringBox: " + text.toString()) + + // IntegerBox + me.count = new IntegerBox(42) + me.console.log("IntegerBox: " + me.count.toString()) + + // ArrayBox + me.list = new ArrayBox() + me.list.push("item1") + me.list.push("item2") + me.console.log("ArrayBox size: " + me.list.size().toString()) + + // MapBox + me.data = new MapBox() + me.data.set("name", "Nyash") + me.data.set("version", "1.0") + me.console.log("MapBox keys: " + me.data.keys().toString()) + + // MathBox + local math = new MathBox() + local result = math.sqrt(16) + me.console.log("MathBox sqrt(16): " + result.toString()) + + return "✅ テスト完了！" + } +} \ No newline at end of file diff --git a/plugins/nyash-test-multibox/Cargo.toml b/plugins/nyash-test-multibox/Cargo.toml new file mode 100644 index 00000000..84a1f9f9 --- /dev/null +++ b/plugins/nyash-test-multibox/Cargo.toml @@ -0,0 +1,9 @@ +[package] +name = "nyash-test-multibox" +version = "0.1.0" +edition = "2021" + +[lib] +crate-type = ["cdylib"] + +[dependencies] \ No newline at end of file diff --git a/plugins/nyash-test-multibox/src/lib.rs b/plugins/nyash-test-multibox/src/lib.rs new file mode 100644 index 00000000..986ef7dc --- /dev/null +++ b/plugins/nyash-test-multibox/src/lib.rs @@ -0,0 +1,373 @@ +//! Test Multi-Box Plugin for Nyash +//! +//! Provides TestBoxA and TestBoxB to demonstrate multi-box plugin support + +use std::collections::HashMap; +use std::os::raw::c_char; +use std::ptr; +use std::sync::Mutex; + +// ============ FFI Types ============ + +#[repr(C)] +pub struct NyashHostVtable { + pub alloc: unsafe extern "C" fn(size: usize) -> *mut u8, + pub free: unsafe extern "C" fn(ptr: *mut u8), + pub wake: unsafe extern "C" fn(handle: u64), + pub log: unsafe extern "C" fn(level: i32, msg: *const c_char), +} + +#[repr(C)] +pub struct NyashMethodInfo { + pub method_id: u32, + pub name: *const c_char, + pub signature: u32, +} + +unsafe impl Sync for NyashMethodInfo {} + +#[repr(C)] +pub struct NyashPluginInfo { + pub type_id: u32, + pub type_name: *const c_char, + pub method_count: usize, + pub methods: *const NyashMethodInfo, +} + +unsafe impl Sync for NyashPluginInfo {} + +// Error codes +const NYB_SUCCESS: i32 = 0; +const NYB_E_INVALID_ARGS: i32 = -4; +const NYB_E_INVALID_HANDLE: i32 = -8; + +// Method IDs +const METHOD_BIRTH: u32 = 0; +const METHOD_HELLO: u32 = 1; +const METHOD_GREET: u32 = 2; +const METHOD_FINI: u32 = u32::MAX; + +// Type IDs +const TYPE_ID_TESTBOX_A: u32 = 200; +const TYPE_ID_TESTBOX_B: u32 = 201; + +// Global state +static mut HOST_VTABLE: Option<&'static NyashHostVtable> = None; +static mut INSTANCES: Option>> = None; +static mut INSTANCE_COUNTER: u32 = 1; + +enum TestInstance { + BoxA { message: String }, + BoxB { counter: i32 }, +} + +// ============ Plugin Info for Each Box Type ============ + +static TESTBOX_A_NAME: &[u8] = b"TestBoxA\0"; +static TESTBOX_B_NAME: &[u8] = b"TestBoxB\0"; + +static METHOD_HELLO_NAME: &[u8] = b"hello\0"; +static METHOD_GREET_NAME: &[u8] = b"greet\0"; +static METHOD_BIRTH_NAME: &[u8] = b"birth\0"; +static METHOD_FINI_NAME: &[u8] = b"fini\0"; + +static TESTBOX_A_METHODS: [NyashMethodInfo; 3] = [ + NyashMethodInfo { + method_id: METHOD_BIRTH, + name: METHOD_BIRTH_NAME.as_ptr() as *const c_char, + signature: 0, + }, + NyashMethodInfo { + method_id: METHOD_HELLO, + name: METHOD_HELLO_NAME.as_ptr() as *const c_char, + signature: 0, + }, + NyashMethodInfo { + method_id: METHOD_FINI, + name: METHOD_FINI_NAME.as_ptr() as *const c_char, + signature: 0, + }, +]; + +static TESTBOX_B_METHODS: [NyashMethodInfo; 3] = [ + NyashMethodInfo { + method_id: METHOD_BIRTH, + name: METHOD_BIRTH_NAME.as_ptr() as *const c_char, + signature: 0, + }, + NyashMethodInfo { + method_id: METHOD_GREET, + name: METHOD_GREET_NAME.as_ptr() as *const c_char, + signature: 0, + }, + NyashMethodInfo { + method_id: METHOD_FINI, + name: METHOD_FINI_NAME.as_ptr() as *const c_char, + signature: 0, + }, +]; + +static TESTBOX_A_INFO: NyashPluginInfo = NyashPluginInfo { + type_id: TYPE_ID_TESTBOX_A, + type_name: TESTBOX_A_NAME.as_ptr() as *const c_char, + method_count: 3, + methods: TESTBOX_A_METHODS.as_ptr(), +}; + +static TESTBOX_B_INFO: NyashPluginInfo = NyashPluginInfo { + type_id: TYPE_ID_TESTBOX_B, + type_name: TESTBOX_B_NAME.as_ptr() as *const c_char, + method_count: 3, + methods: TESTBOX_B_METHODS.as_ptr(), +}; + +// ============ Plugin Entry Points ============ + +#[no_mangle] +pub extern "C" fn nyash_plugin_abi() -> u32 { + 1 // BID-1 ABI version +} + +#[no_mangle] +pub extern "C" fn nyash_plugin_init( + host: *const NyashHostVtable, + _info: *mut std::ffi::c_void, // For v2, we use get_box_info instead +) -> i32 { + if host.is_null() { + return NYB_E_INVALID_ARGS; + } + + unsafe { + HOST_VTABLE = Some(&*host); + INSTANCES = Some(Mutex::new(HashMap::new())); + + // Log initialization + log_info("Multi-box test plugin initialized"); + } + + NYB_SUCCESS +} + +// ============ Multi-Box v2 Functions ============ + +#[no_mangle] +pub extern "C" fn nyash_plugin_get_box_count() -> u32 { + 2 // TestBoxA and TestBoxB +} + +#[no_mangle] +pub extern "C" fn nyash_plugin_get_box_info(index: u32) -> *const NyashPluginInfo { + match index { + 0 => &TESTBOX_A_INFO as *const NyashPluginInfo, + 1 => &TESTBOX_B_INFO as *const NyashPluginInfo, + _ => ptr::null(), + } +} + +#[no_mangle] +pub extern "C" fn nyash_plugin_get_type_id(box_name: *const c_char) -> u32 { + if box_name.is_null() { + return 0; + } + + unsafe { + let name = std::ffi::CStr::from_ptr(box_name).to_string_lossy(); + match name.as_ref() { + "TestBoxA" => TYPE_ID_TESTBOX_A, + "TestBoxB" => TYPE_ID_TESTBOX_B, + _ => 0, + } + } +} + +// ============ Method Invocation ============ + +#[no_mangle] +pub extern "C" fn nyash_plugin_invoke( + type_id: u32, + method_id: u32, + instance_id: u32, + _args: *const u8, + _args_len: usize, + result: *mut u8, + result_len: *mut usize, +) -> i32 { + unsafe { + match (type_id, method_id) { + // TestBoxA methods + (TYPE_ID_TESTBOX_A, METHOD_BIRTH) => { + create_instance_a(result, result_len) + } + (TYPE_ID_TESTBOX_A, METHOD_HELLO) => { + hello_method(instance_id, result, result_len) + } + (TYPE_ID_TESTBOX_A, METHOD_FINI) => { + destroy_instance(instance_id) + } + + // TestBoxB methods + (TYPE_ID_TESTBOX_B, METHOD_BIRTH) => { + create_instance_b(result, result_len) + } + (TYPE_ID_TESTBOX_B, METHOD_GREET) => { + greet_method(instance_id, result, result_len) + } + (TYPE_ID_TESTBOX_B, METHOD_FINI) => { + destroy_instance(instance_id) + } + + _ => NYB_E_INVALID_ARGS, + } + } +} + +// ============ Method Implementations ============ + +unsafe fn create_instance_a(result: *mut u8, result_len: *mut usize) -> i32 { + if let Some(ref mutex) = INSTANCES { + if let Ok(mut map) = mutex.lock() { + let id = INSTANCE_COUNTER; + INSTANCE_COUNTER += 1; + + map.insert(id, TestInstance::BoxA { + message: "Hello from TestBoxA!".to_string(), + }); + + // Return instance ID + if *result_len >= 4 { + let bytes = id.to_le_bytes(); + ptr::copy_nonoverlapping(bytes.as_ptr(), result, 4); + *result_len = 4; + + log_info(&format!("Created TestBoxA instance {}", id)); + return NYB_SUCCESS; + } + } + } + NYB_E_INVALID_ARGS +} + +unsafe fn create_instance_b(result: *mut u8, result_len: *mut usize) -> i32 { + if let Some(ref mutex) = INSTANCES { + if let Ok(mut map) = mutex.lock() { + let id = INSTANCE_COUNTER; + INSTANCE_COUNTER += 1; + + map.insert(id, TestInstance::BoxB { + counter: 0, + }); + + // Return instance ID + if *result_len >= 4 { + let bytes = id.to_le_bytes(); + ptr::copy_nonoverlapping(bytes.as_ptr(), result, 4); + *result_len = 4; + + log_info(&format!("Created TestBoxB instance {}", id)); + return NYB_SUCCESS; + } + } + } + NYB_E_INVALID_ARGS +} + +unsafe fn hello_method(instance_id: u32, result: *mut u8, result_len: *mut usize) -> i32 { + if let Some(ref mutex) = INSTANCES { + if let Ok(map) = mutex.lock() { + if let Some(TestInstance::BoxA { message }) = map.get(&instance_id) { + // Return message as TLV string + write_tlv_string(message, result, result_len) + } else { + NYB_E_INVALID_HANDLE + } + } else { + NYB_E_INVALID_ARGS + } + } else { + NYB_E_INVALID_ARGS + } +} + +unsafe fn greet_method(instance_id: u32, result: *mut u8, result_len: *mut usize) -> i32 { + if let Some(ref mutex) = INSTANCES { + if let Ok(mut map) = mutex.lock() { + if let Some(TestInstance::BoxB { counter }) = map.get_mut(&instance_id) { + *counter += 1; + let message = format!("Greeting #{} from TestBoxB!", counter); + + // Return message as TLV string + write_tlv_string(&message, result, result_len) + } else { + NYB_E_INVALID_HANDLE + } + } else { + NYB_E_INVALID_ARGS + } + } else { + NYB_E_INVALID_ARGS + } +} + +unsafe fn destroy_instance(instance_id: u32) -> i32 { + if let Some(ref mutex) = INSTANCES { + if let Ok(mut map) = mutex.lock() { + if map.remove(&instance_id).is_some() { + log_info(&format!("Destroyed instance {}", instance_id)); + NYB_SUCCESS + } else { + NYB_E_INVALID_HANDLE + } + } else { + NYB_E_INVALID_ARGS + } + } else { + NYB_E_INVALID_ARGS + } +} + +// ============ Helper Functions ============ + +unsafe fn write_tlv_string(s: &str, result: *mut u8, result_len: *mut usize) -> i32 { + let bytes = s.as_bytes(); + let needed = 8 + bytes.len(); // header(4) + entry(4) + string + + if *result_len < needed { + return NYB_E_INVALID_ARGS; + } + + // TLV header + *result = 1; // version low + *result.offset(1) = 0; // version high + *result.offset(2) = 1; // argc low + *result.offset(3) = 0; // argc high + + // String entry + *result.offset(4) = 6; // Tag::String + *result.offset(5) = 0; // padding + let len_bytes = (bytes.len() as u16).to_le_bytes(); + *result.offset(6) = len_bytes[0]; + *result.offset(7) = len_bytes[1]; + + // String data + ptr::copy_nonoverlapping(bytes.as_ptr(), result.offset(8), bytes.len()); + + *result_len = needed; + NYB_SUCCESS +} + +unsafe fn log_info(message: &str) { + if let Some(vtable) = HOST_VTABLE { + if let Ok(c_str) = std::ffi::CString::new(message) { + (vtable.log)(1, c_str.as_ptr()); + } + } +} + +#[no_mangle] +pub extern "C" fn nyash_plugin_shutdown() { + unsafe { + log_info("Multi-box test plugin shutting down"); + INSTANCES = None; + HOST_VTABLE = None; + } +} \ No newline at end of file diff --git a/src/config/nyash_toml_v2.rs b/src/config/nyash_toml_v2.rs new file mode 100644 index 00000000..b0dff65c --- /dev/null +++ b/src/config/nyash_toml_v2.rs @@ -0,0 +1,145 @@ +//! nyash.toml v2 configuration parser +//! +//! Supports both legacy single-box plugins and new multi-box plugins + +use serde::{Deserialize, Serialize}; +use std::collections::HashMap; + +/// Root configuration structure +#[derive(Debug, Deserialize, Serialize)] +pub struct NyashConfigV2 { + /// Legacy single-box plugins (for backward compatibility) + #[serde(default)] + pub plugins: HashMap, + + /// Plugin-specific configurations (legacy) + #[serde(flatten)] + pub plugin_configs: HashMap, + + /// New multi-box plugin libraries + #[serde(skip_serializing_if = "Option::is_none")] + pub libraries: Option, + + /// Box type definitions + #[serde(skip_serializing_if = "Option::is_none")] + pub types: Option>, +} + +/// Plugin libraries section +#[derive(Debug, Deserialize, Serialize)] +pub struct PluginLibraries { + #[serde(flatten)] + pub libraries: HashMap, +} + +/// Library definition +#[derive(Debug, Deserialize, Serialize)] +pub struct LibraryDefinition { + pub plugin_path: String, + pub provides: Vec, +} + +/// Box type definition +#[derive(Debug, Deserialize, Serialize)] +pub struct BoxTypeDefinition { + pub library: String, + pub type_id: u32, + pub methods: HashMap, +} + +/// Method definition +#[derive(Debug, Deserialize, Serialize)] +pub struct MethodDefinition { + #[serde(default)] + pub args: Vec, + + #[serde(skip_serializing_if = "Option::is_none")] + pub returns: Option, +} + +/// Argument definition +#[derive(Debug, Deserialize, Serialize)] +pub struct ArgumentDefinition { + #[serde(skip_serializing_if = "Option::is_none")] + pub name: Option, + + pub from: String, + pub to: String, +} + +impl NyashConfigV2 { + /// Parse nyash.toml file + pub fn from_file(path: &str) -> Result> { + let content = std::fs::read_to_string(path)?; + let config: NyashConfigV2 = toml::from_str(&content)?; + Ok(config) + } + + /// Check if using v2 format + pub fn is_v2_format(&self) -> bool { + self.libraries.is_some() || self.types.is_some() + } + + /// Get all box types provided by a library + pub fn get_box_types_for_library(&self, library_name: &str) -> Vec { + if let Some(libs) = &self.libraries { + if let Some(lib_def) = libs.libraries.get(library_name) { + return lib_def.provides.clone(); + } + } + vec![] + } + + /// Get library name for a box type + pub fn get_library_for_box_type(&self, box_type: &str) -> Option { + // Check v2 format first + if let Some(types) = &self.types { + if let Some(type_def) = types.get(box_type) { + return Some(type_def.library.clone()); + } + } + + // Fall back to legacy format + self.plugins.get(box_type).cloned() + } +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn test_parse_legacy_format() { + let toml_str = r#" +[plugins] +FileBox = "nyash-filebox-plugin" + +[plugins.FileBox.methods] +read = { args = [] } +"#; + + let config: NyashConfigV2 = toml::from_str(toml_str).unwrap(); + assert_eq!(config.plugins.get("FileBox"), Some(&"nyash-filebox-plugin".to_string())); + assert!(!config.is_v2_format()); + } + + #[test] + fn test_parse_v2_format() { + let toml_str = r#" +[plugins.libraries] +"nyash-network" = { + plugin_path = "libnyash_network.so", + provides = ["SocketBox", "HTTPServerBox"] +} + +[plugins.types.SocketBox] +library = "nyash-network" +type_id = 100 +methods = { bind = { args = [] } } +"#; + + let config: NyashConfigV2 = toml::from_str(toml_str).unwrap(); + assert!(config.is_v2_format()); + assert_eq!(config.get_box_types_for_library("nyash-network"), vec!["SocketBox", "HTTPServerBox"]); + } +} \ No newline at end of file diff --git a/tools/plugin-tester/src/main.rs b/tools/plugin-tester/src/main.rs index cb30aea6..a5ca22a4 100644 --- a/tools/plugin-tester/src/main.rs +++ b/tools/plugin-tester/src/main.rs @@ -1,9 +1,9 @@ -//! Nyash Plugin Tester +//! Nyash Plugin Tester - Multi-Box Type Support (v2) //! //! プラグイン開発者向けの診断ツール -//! Box名を決め打ちせず、プラグインから取得する +//! 単一Box型・複数Box型の両方をサポート -use clap::Parser; +use clap::{Parser, Subcommand}; use colored::*; use libloading::{Library, Symbol}; use serde::Deserialize; @@ -49,54 +49,65 @@ struct NyashConfig { #[derive(Debug)] struct PluginConfig { - methods: Option>, + methods: HashMap, } -#[derive(Deserialize, Debug)] -struct MethodConfig { - args: Vec, +#[derive(Debug, Deserialize)] +struct MethodDef { + args: Vec, + #[serde(skip_serializing_if = "Option::is_none")] returns: Option, } -#[derive(Deserialize, Debug)] -struct TypeConversion { +#[derive(Debug, Deserialize)] +struct ArgDef { + #[serde(skip_serializing_if = "Option::is_none")] name: Option, from: String, to: String, } -// ============ CLI Arguments ============ +// ============ CLI ============ -#[derive(Parser, Debug)] +#[derive(Parser)] #[command(name = "plugin-tester")] -#[command(about = "Nyash plugin diagnostic tool", long_about = None)] +#[command(about = "Nyash plugin testing tool", long_about = None)] struct Args { - /// Action to perform #[command(subcommand)] command: Commands, } -#[derive(clap::Subcommand, Debug)] +#[derive(Subcommand)] enum Commands { - /// Check plugin and display information + /// Check plugin exports and basic functionality Check { /// Path to plugin .so file plugin: PathBuf, + + /// Check for multiple Box types (v2 plugin) + #[arg(short = 'm', long)] + multi: bool, }, - /// Test plugin lifecycle (birth/fini) + /// Test Box lifecycle (birth/fini) Lifecycle { /// Path to plugin .so file plugin: PathBuf, + + /// Specify Box type name (for multi-box plugins) + #[arg(short = 'b', long)] + box_type: Option, }, - /// File I/O end-to-end test (open/write/read/close) + /// Test file I/O operations Io { /// Path to plugin .so file plugin: PathBuf, }, - /// Debug TLV encoding/decoding with detailed output + /// Debug TLV encoding/decoding TlvDebug { - /// Path to plugin .so file - plugin: PathBuf, + /// Path to plugin .so file (optional) + #[arg(short, long)] + plugin: Option, + /// Test message to encode/decode #[arg(short, long, default_value = "Hello TLV Debug!")] message: String, @@ -156,8 +167,14 @@ fn main() { let args = Args::parse(); match args.command { - Commands::Check { plugin } => check_plugin(&plugin), - Commands::Lifecycle { plugin } => test_lifecycle(&plugin), + Commands::Check { plugin, multi } => { + if multi { + check_multi_box_plugin(&plugin) + } else { + check_plugin(&plugin) + } + }, + Commands::Lifecycle { plugin, box_type } => test_lifecycle(&plugin, box_type), Commands::Io { plugin } => test_file_io(&plugin), Commands::TlvDebug { plugin, message } => test_tlv_debug(&plugin, &message), Commands::Typecheck { plugin, config } => typecheck_plugin(&plugin, &config), @@ -208,44 +225,32 @@ fn tlv_encode_two_strings(a: &str, b: &str, buf: &mut Vec) { buf[header_pos+2..header_pos+4].copy_from_slice(&argc.to_le_bytes()); } -fn tlv_encode_i32(v: i32, buf: &mut Vec) { - let header_pos = buf.len(); - buf.extend_from_slice(&[0,0,0,0]); - buf.push(Tag::I32 as u8); - buf.push(0); - buf.extend_from_slice(&4u16.to_le_bytes()); - buf.extend_from_slice(&v.to_le_bytes()); - buf[header_pos..header_pos+2].copy_from_slice(&TLV_VERSION.to_le_bytes()); - buf[header_pos+2..header_pos+4].copy_from_slice(&1u16.to_le_bytes()); +fn tlv_decode_i32(data: &[u8]) -> Result { + if data.len() < 12 { + return Err("Buffer too short for I32 TLV".to_string()); + } + let version = u16::from_le_bytes([data[0], data[1]]); + let argc = u16::from_le_bytes([data[2], data[3]]); + if version != TLV_VERSION || argc != 1 { + return Err(format!("Invalid TLV header: v{} argc={}", version, argc)); + } + let tag = data[4]; + if tag != Tag::I32 as u8 { + return Err(format!("Expected I32 tag, got {}", tag)); + } + let len = u16::from_le_bytes([data[6], data[7]]); + if len != 4 { + return Err(format!("Invalid I32 length: {}", len)); + } + Ok(i32::from_le_bytes([data[8], data[9], data[10], data[11]])) } -fn tlv_encode_bytes(data: &[u8], buf: &mut Vec) { - let header_pos = buf.len(); - buf.extend_from_slice(&[0,0,0,0]); - buf.push(Tag::Bytes as u8); - buf.push(0); - buf.extend_from_slice(&(data.len() as u16).to_le_bytes()); - buf.extend_from_slice(data); - buf[header_pos..header_pos+2].copy_from_slice(&TLV_VERSION.to_le_bytes()); - buf[header_pos+2..header_pos+4].copy_from_slice(&1u16.to_le_bytes()); -} - -fn tlv_decode_first(bytes: &[u8]) -> Option<(u8, &[u8])> { - if bytes.len() < 4 { return None; } - let argc = u16::from_le_bytes([bytes[2], bytes[3]]); - if argc == 0 { return None; } - if bytes.len() < 8 { return None; } - let tag = bytes[4]; - let size = u16::from_le_bytes([bytes[6], bytes[7]]) as usize; - if bytes.len() < 8+size { return None; } - Some((tag, &bytes[8..8+size])) -} +// ============ Plugin Check Functions ============ fn check_plugin(path: &PathBuf) { - println!("{}", "=== Nyash Plugin Checker ===".bold()); + println!("{}", "=== Plugin Check (Single Box Type) ===".bold()); println!("Plugin: {}", path.display()); - // プラグインをロード let library = match unsafe { Library::new(path) } { Ok(lib) => lib, Err(e) => { @@ -345,11 +350,12 @@ fn check_plugin(path: &PathBuf) { println!("\n{}", "Check completed!".green().bold()); } -fn test_lifecycle(path: &PathBuf) { - println!("{}", "=== Lifecycle Test ===".bold()); - println!("Testing birth/fini for: {}", path.display()); +// ============ Multi-Box Plugin Support (v2) ============ - // プラグインをロード +fn check_multi_box_plugin(path: &PathBuf) { + println!("{}", "=== Plugin Check (Multi-Box Type v2) ===".bold()); + println!("Plugin: {}", path.display()); + let library = match unsafe { Library::new(path) } { Ok(lib) => lib, Err(e) => { @@ -357,24 +363,41 @@ fn test_lifecycle(path: &PathBuf) { return; } }; - + + println!("{}: Plugin loaded successfully", "✓".green()); + + // Check for v2 functions unsafe { - // ABI version - let abi_fn: Symbol u32> = match library.get(b"nyash_plugin_abi") { - Ok(f) => f, - Err(e) => { - eprintln!("{}: nyash_plugin_abi not found: {}", "ERROR".red(), e); - return; - } - }; - let abi_version = abi_fn(); - println!("{}: ABI version: {}", "✓".green(), abi_version); - if abi_version != 1 { - eprintln!("{}: Unsupported ABI version (expected 1)", "WARNING".yellow()); + // Check if this is a v2 plugin + let has_v2 = library.get:: u32>>(b"nyash_plugin_get_box_count").is_ok(); + + if !has_v2 { + println!("{}: This is not a v2 multi-box plugin", "INFO".yellow()); + println!(" Falling back to single-box check...\n"); + drop(library); + check_plugin(path); + return; } - - // init - let init_fn: Symbol i32> = + + // Get box count + let get_count_fn: Symbol u32> = + library.get(b"nyash_plugin_get_box_count").unwrap(); + + let box_count = get_count_fn(); + println!("{}: Plugin provides {} Box types", "✓".green(), box_count); + + // Get box info function + let get_info_fn: Symbol *const NyashPluginInfo> = + match library.get(b"nyash_plugin_get_box_info") { + Ok(f) => f, + Err(e) => { + eprintln!("{}: nyash_plugin_get_box_info not found: {}", "ERROR".red(), e); + return; + } + }; + + // Initialize plugin + let init_fn: Symbol i32> = match library.get(b"nyash_plugin_init") { Ok(f) => f, Err(e) => { @@ -382,346 +405,84 @@ fn test_lifecycle(path: &PathBuf) { return; } }; - let mut plugin_info = std::mem::zeroed::(); - let result = init_fn(&HOST_VTABLE, &mut plugin_info); + + let result = init_fn(&HOST_VTABLE, std::ptr::null_mut()); if result != 0 { - eprintln!("{}: nyash_plugin_init failed with code {}", "ERROR".red(), result); + eprintln!("{}: Plugin initialization failed", "ERROR".red()); return; } - println!("{}: Plugin initialized", "✓".green()); - - // invoke - let invoke_fn: Symbol i32> = - match library.get(b"nyash_plugin_invoke") { - Ok(f) => f, - Err(e) => { - eprintln!("{}: nyash_plugin_invoke not found: {}", "ERROR".red(), e); - return; - } - }; - - let type_id = plugin_info.type_id; - println!("{}: BoxType ID = {}", "i".blue(), type_id); - - // birth - let mut out = [0u8; 8]; - let mut out_len: usize = out.len(); - let rc = invoke_fn(type_id, 0, 0, std::ptr::null(), 0, out.as_mut_ptr(), &mut out_len as *mut usize); - if rc != 0 { - eprintln!("{}: birth invoke failed with code {}", "ERROR".red(), rc); - return; - } - if out_len < 4 { - eprintln!("{}: birth returned too small result ({} bytes)", "ERROR".red(), out_len); - return; - } - let instance_id = u32::from_le_bytes(out[0..4].try_into().unwrap()); - println!("{}: birth → instance_id={}", "✓".green(), instance_id); - - // fini - let rc = invoke_fn(type_id, u32::MAX, instance_id, std::ptr::null(), 0, std::ptr::null_mut(), std::ptr::null_mut()); - if rc != 0 { - eprintln!("{}: fini invoke failed with code {}", "ERROR".red(), rc); - return; - } - println!("{}: fini → instance {} cleaned", "✓".green(), instance_id); - - // shutdown - if let Ok(shutdown_fn) = library.get::>(b"nyash_plugin_shutdown") { - shutdown_fn(); - println!("{}: Plugin shutdown completed", "✓".green()); - } - } - - println!("\n{}", "Lifecycle test completed!".green().bold()); -} - -fn test_file_io(path: &PathBuf) { - println!("{}", "=== File I/O Test ===".bold()); - println!("Testing open/write/read/close: {}", path.display()); - - // Load - let library = match unsafe { Library::new(path) } { - Ok(lib) => lib, - Err(e) => { - eprintln!("{}: Failed to load plugin: {}", "ERROR".red(), e); - return; - } - }; - unsafe { - let abi: Symbol u32> = library.get(b"nyash_plugin_abi").unwrap(); - println!("{}: ABI version: {}", "✓".green(), abi()); - let init: Symbol i32> = library.get(b"nyash_plugin_init").unwrap(); - let mut info = std::mem::zeroed::(); - assert_eq!(0, init(&HOST_VTABLE, &mut info)); - let invoke: Symboli32> = library.get(b"nyash_plugin_invoke").unwrap(); - let shutdown: Symbol = library.get(b"nyash_plugin_shutdown").unwrap(); - - // birth - let mut buf_len: usize = 0; - let rc = invoke(info.type_id, 0, 0, std::ptr::null(), 0, std::ptr::null_mut(), &mut buf_len as *mut usize); - assert!(rc == -1 && buf_len >= 4, "unexpected birth preflight"); - let mut out = vec![0u8; buf_len]; - let mut out_len = buf_len; - assert_eq!(0, invoke(info.type_id, 0, 0, std::ptr::null(), 0, out.as_mut_ptr(), &mut out_len as *mut usize)); - let instance_id = u32::from_le_bytes(out[0..4].try_into().unwrap()); - println!("{}: birth → instance_id={}", "✓".green(), instance_id); - - // open: write mode - let mut args = Vec::new(); - let test_path = "plugins/nyash-filebox-plugin/target/test_io.txt"; - tlv_encode_two_strings(test_path, "w", &mut args); - let mut res_len: usize = 0; - let rc = invoke(info.type_id, 1, instance_id, args.as_ptr(), args.len(), std::ptr::null_mut(), &mut res_len as *mut usize); - assert!(rc == -1 || rc == 0); - let mut res = vec![0u8; res_len.max(4)]; - let mut rl = res_len; - let _ = invoke(info.type_id, 1, instance_id, args.as_ptr(), args.len(), res.as_mut_ptr(), &mut rl as *mut usize); - println!("{}: open(w)", "✓".green()); - - // write - let content = b"Hello from plugin-tester!"; - let mut wargs = Vec::new(); - tlv_encode_bytes(content, &mut wargs); - let mut rlen: usize = 0; - let rc = invoke(info.type_id, 3, instance_id, wargs.as_ptr(), wargs.len(), std::ptr::null_mut(), &mut rlen as *mut usize); - assert!(rc == -1 || rc == 0); - let mut wb = vec![0u8; rlen.max(8)]; - let mut rl2 = rlen; - let _ = invoke(info.type_id, 3, instance_id, wargs.as_ptr(), wargs.len(), wb.as_mut_ptr(), &mut rl2 as *mut usize); - if let Some((tag, payload)) = tlv_decode_first(&wb[..rl2]) { - assert_eq!(tag, Tag::I32 as u8); - let mut n = [0u8;4]; n.copy_from_slice(payload); - let written = i32::from_le_bytes(n); - println!("{}: write {} bytes", "✓".green(), written); - } - - // close - let mut clen: usize = 0; - let _ = invoke(info.type_id, 4, instance_id, std::ptr::null(), 0, std::ptr::null_mut(), &mut clen as *mut usize); - let mut cb = vec![0u8; clen.max(4)]; let mut cbl = clen; let _ = invoke(info.type_id, 4, instance_id, std::ptr::null(), 0, cb.as_mut_ptr(), &mut cbl as *mut usize); - println!("{}: close", "✓".green()); - - // reopen read - let mut args2 = Vec::new(); tlv_encode_two_strings(test_path, "r", &mut args2); - let mut r0: usize = 0; let _ = invoke(info.type_id, 1, instance_id, args2.as_ptr(), args2.len(), std::ptr::null_mut(), &mut r0 as *mut usize); - let mut ob = vec![0u8; r0.max(4)]; let mut obl=r0; let _=invoke(info.type_id,1,instance_id,args2.as_ptr(),args2.len(),ob.as_mut_ptr(),&mut obl as *mut usize); - println!("{}: open(r)", "✓".green()); - - // read 1024 - let mut rargs = Vec::new(); tlv_encode_i32(1024, &mut rargs); - let mut rneed: usize = 0; let rc = invoke(info.type_id, 2, instance_id, rargs.as_ptr(), rargs.len(), std::ptr::null_mut(), &mut rneed as *mut usize); - assert!(rc == -1 || rc == 0); - let mut rb = vec![0u8; rneed.max(16)]; let mut rbl=rneed; let rc2=invoke(info.type_id,2,instance_id,rargs.as_ptr(),rargs.len(),rb.as_mut_ptr(),&mut rbl as *mut usize); - if rc2 != 0 { println!("{}: read rc={} (expected 0)", "WARN".yellow(), rc2); } - if let Some((tag, payload)) = tlv_decode_first(&rb[..rbl]) { - assert_eq!(tag, Tag::Bytes as u8); - let s = String::from_utf8_lossy(payload).to_string(); - println!("{}: read {} bytes → '{}'", "✓".green(), payload.len(), s); - } else { - println!("{}: read decode failed (len={})", "WARN".yellow(), rbl); - } - - // close & shutdown - let mut clen2: usize = 0; let _=invoke(info.type_id,4,instance_id,std::ptr::null(),0,std::ptr::null_mut(),&mut clen2 as *mut usize); - shutdown(); - println!("\n{}", "File I/O test completed!".green().bold()); - } -} - -fn test_tlv_debug(path: &PathBuf, message: &str) { - println!("{}", "=== TLV Debug Test ===".bold()); - println!("Testing TLV encoding/decoding with: '{}'", message); - - // Load plugin - let library = match unsafe { Library::new(path) } { - Ok(lib) => lib, - Err(e) => { - eprintln!("{}: Failed to load plugin: {}", "ERROR".red(), e); - return; - } - }; - - unsafe { - let abi: Symbol u32> = library.get(b"nyash_plugin_abi").unwrap(); - println!("{}: ABI version: {}", "✓".green(), abi()); - let init: Symbol i32> = library.get(b"nyash_plugin_init").unwrap(); - let mut info = std::mem::zeroed::(); - assert_eq!(0, init(&HOST_VTABLE, &mut info)); + println!("\n{}", "Box Types:".bold()); - let invoke: Symboli32> = library.get(b"nyash_plugin_invoke").unwrap(); - let shutdown: Symbol = library.get(b"nyash_plugin_shutdown").unwrap(); - - // Test TLV encoding - println!("\n{}", "--- Encoding Test ---".cyan()); - let mut encoded = Vec::new(); - tlv_encode_string(message, &mut encoded); - - println!("Original message: '{}'", message); - println!("Encoded TLV ({} bytes): {:02x?}", encoded.len(), encoded); - - // Hex dump for readability - print!("Hex dump: "); - for (i, byte) in encoded.iter().enumerate() { - if i % 16 == 0 && i > 0 { print!("\n "); } - print!("{:02x} ", byte); - } - println!(); - - // Test TLV decoding - println!("\n{}", "--- Decoding Test ---".cyan()); - if let Some((tag, payload)) = tlv_decode_first(&encoded) { - println!("Decoded tag: {} ({})", tag, - match tag { - 6 => "String", - 7 => "Bytes", - _ => "Unknown" - }); - println!("Decoded payload ({} bytes): {:02x?}", payload.len(), payload); - - if tag == Tag::String as u8 || tag == Tag::Bytes as u8 { - let decoded_str = String::from_utf8_lossy(payload); - println!("Decoded string: '{}'", decoded_str); - - if decoded_str == message { - println!("{}: TLV round-trip successful!", "✓".green()); - } else { - println!("{}: TLV round-trip failed! Expected: '{}', Got: '{}'", - "✗".red(), message, decoded_str); - } + // Display info for each Box type + for i in 0..box_count { + let info_ptr = get_info_fn(i); + if info_ptr.is_null() { + eprintln!("{}: Failed to get info for box index {}", "ERROR".red(), i); + continue; } - } else { - println!("{}: Failed to decode TLV!", "✗".red()); - } - - // Test with plugin write/read - println!("\n{}", "--- Plugin Round-trip Test ---".cyan()); - - // birth - let mut buf_len: usize = 0; - let rc = invoke(info.type_id, 0, 0, std::ptr::null(), 0, std::ptr::null_mut(), &mut buf_len); - assert!(rc == -1 && buf_len >= 4); - let mut out = vec![0u8; buf_len]; - let mut out_len = buf_len; - assert_eq!(0, invoke(info.type_id, 0, 0, std::ptr::null(), 0, out.as_mut_ptr(), &mut out_len)); - let instance_id = u32::from_le_bytes(out[0..4].try_into().unwrap()); - println!("{}: birth → instance_id={}", "✓".green(), instance_id); - - // Test file write - let test_path = "plugins/nyash-filebox-plugin/target/tlv_debug_test.txt"; - let mut args = Vec::new(); - tlv_encode_two_strings(test_path, "w", &mut args); - println!("Write args TLV ({} bytes): {:02x?}", args.len(), &args[..args.len().min(32)]); - - let mut need: usize = 0; - let _ = invoke(info.type_id, 1, instance_id, args.as_ptr(), args.len(), std::ptr::null_mut(), &mut need); - let mut obuf = vec![0u8; need.max(4)]; - let mut olen = need; - let _ = invoke(info.type_id, 1, instance_id, args.as_ptr(), args.len(), obuf.as_mut_ptr(), &mut olen); - println!("{}: open(w) successful", "✓".green()); - - // Write test message - let mut write_args = Vec::new(); - tlv_encode_string(message, &mut write_args); - println!("Write message TLV ({} bytes): {:02x?}", write_args.len(), &write_args[..write_args.len().min(32)]); - - let mut wneed: usize = 0; - let _ = invoke(info.type_id, 3, instance_id, write_args.as_ptr(), write_args.len(), std::ptr::null_mut(), &mut wneed); - let mut wbuf = vec![0u8; wneed.max(4)]; - let mut wlen = wneed; - let _ = invoke(info.type_id, 3, instance_id, write_args.as_ptr(), write_args.len(), wbuf.as_mut_ptr(), &mut wlen); - println!("{}: write successful", "✓".green()); - - // Close - let mut clen: usize = 0; - let _ = invoke(info.type_id, 4, instance_id, std::ptr::null(), 0, std::ptr::null_mut(), &mut clen); - let mut cb = vec![0u8; clen.max(4)]; - let mut cbl = clen; - let _ = invoke(info.type_id, 4, instance_id, std::ptr::null(), 0, cb.as_mut_ptr(), &mut cbl); - println!("{}: close successful", "✓".green()); - - // Reopen for read - let mut read_args = Vec::new(); - tlv_encode_two_strings(test_path, "r", &mut read_args); - let mut rneed: usize = 0; - let _ = invoke(info.type_id, 1, instance_id, read_args.as_ptr(), read_args.len(), std::ptr::null_mut(), &mut rneed); - let mut robuf = vec![0u8; rneed.max(4)]; - let mut rolen = rneed; - let _ = invoke(info.type_id, 1, instance_id, read_args.as_ptr(), read_args.len(), robuf.as_mut_ptr(), &mut rolen); - println!("{}: open(r) successful", "✓".green()); - - // Read back - let mut size_args = Vec::new(); - tlv_encode_i32(1024, &mut size_args); - let mut read_need: usize = 0; - let rc = invoke(info.type_id, 2, instance_id, size_args.as_ptr(), size_args.len(), std::ptr::null_mut(), &mut read_need); - println!("Read preflight: rc={}, need={} bytes", rc, read_need); - - let mut read_buf = vec![0u8; read_need.max(16)]; - let mut read_len = read_need; - let rc2 = invoke(info.type_id, 2, instance_id, size_args.as_ptr(), size_args.len(), read_buf.as_mut_ptr(), &mut read_len); - println!("Read actual: rc={}, got={} bytes", rc2, read_len); - - if read_len > 0 { - println!("Read result TLV ({} bytes): {:02x?}", read_len, &read_buf[..read_len.min(32)]); - // Try to decode - if let Some((tag, payload)) = tlv_decode_first(&read_buf[..read_len]) { - println!("Read decoded tag: {} ({})", tag, - match tag { - 6 => "String", - 7 => "Bytes", - _ => "Unknown" - }); - let read_message = String::from_utf8_lossy(payload); - println!("Read decoded message: '{}'", read_message); - - if read_message == message { - println!("{}: Plugin round-trip successful!", "✓".green()); - } else { - println!("{}: Plugin round-trip failed! Expected: '{}', Got: '{}'", - "✗".red(), message, read_message); - } + let info = &*info_ptr; + let box_name = if info.type_name.is_null() { + "".to_string() } else { - println!("{}: Failed to decode read result!", "✗".red()); - // Show detailed hex analysis - if read_len >= 4 { - let version = u16::from_le_bytes([read_buf[0], read_buf[1]]); - let argc = u16::from_le_bytes([read_buf[2], read_buf[3]]); - println!("TLV Header analysis: version={}, argc={}", version, argc); + CStr::from_ptr(info.type_name).to_string_lossy().to_string() + }; + + println!("\n {}. {} (ID: {})", i + 1, box_name.cyan(), info.type_id); + println!(" Methods: {}", info.method_count); + + // Display methods + if info.method_count > 0 && !info.methods.is_null() { + let methods = std::slice::from_raw_parts(info.methods, info.method_count); + + for method in methods { + let method_name = if method.name.is_null() { + "".to_string() + } else { + CStr::from_ptr(method.name).to_string_lossy().to_string() + }; - if read_len >= 8 { - let entry_tag = read_buf[4]; - let entry_reserved = read_buf[5]; - let entry_len = u16::from_le_bytes([read_buf[6], read_buf[7]]); - println!("First entry: tag={}, reserved={}, len={}", entry_tag, entry_reserved, entry_len); - } + let method_type = match method.method_id { + 0 => " (constructor)".yellow(), + id if id == u32::MAX => " (destructor)".yellow(), + _ => "".normal(), + }; + + println!(" - {} [ID: {}]{}", + method_name, + method.method_id, + method_type + ); } } } - shutdown(); - println!("\n{}", "TLV Debug test completed!".green().bold()); + // Check for get_type_id function + if let Ok(get_type_id_fn) = library.get:: u32>>(b"nyash_plugin_get_type_id") { + println!("\n{}: Plugin supports type name resolution", "✓".green()); + + // Test type name resolution + for test_name in ["TestBoxA", "TestBoxB", "UnknownBox"] { + let c_name = CString::new(test_name).unwrap(); + let type_id = get_type_id_fn(c_name.as_ptr()); + if type_id != 0 { + println!(" {} -> type_id: {}", test_name, type_id); + } else { + println!(" {} -> not found", test_name.dimmed()); + } + } + } } + + println!("\n{}", "Multi-box check completed!".green().bold()); } -fn typecheck_plugin(plugin_path: &PathBuf, config_path: &PathBuf) { - println!("{}", "=== Type Information Validation ===".bold()); - println!("Plugin: {}", plugin_path.display()); - println!("Config: {}", config_path.display()); - - // Load and parse configuration - let config = match load_nyash_config(config_path) { - Ok(c) => c, - Err(e) => { - eprintln!("{}: Failed to load configuration: {}", "ERROR".red(), e); - return; - } - }; +fn test_lifecycle(path: &PathBuf, box_type: Option) { + println!("{}", "=== Lifecycle Test ===".bold()); // Load plugin - let library = match unsafe { Library::new(plugin_path) } { + let library = match unsafe { Library::new(path) } { Ok(lib) => lib, Err(e) => { eprintln!("{}: Failed to load plugin: {}", "ERROR".red(), e); @@ -730,17 +491,6 @@ fn typecheck_plugin(plugin_path: &PathBuf, config_path: &PathBuf) { }; unsafe { - // ABI version check - let abi_fn: Symbol u32> = match library.get(b"nyash_plugin_abi") { - Ok(f) => f, - Err(e) => { - eprintln!("{}: nyash_plugin_abi not found: {}", "ERROR".red(), e); - return; - } - }; - let abi_version = abi_fn(); - println!("{}: ABI version: {}", "✓".green(), abi_version); - // Initialize plugin let init_fn: Symbol i32> = match library.get(b"nyash_plugin_init") { @@ -755,266 +505,284 @@ fn typecheck_plugin(plugin_path: &PathBuf, config_path: &PathBuf) { let result = init_fn(&HOST_VTABLE, &mut plugin_info); if result != 0 { - eprintln!("{}: nyash_plugin_init failed with code {}", "ERROR".red(), result); + eprintln!("{}: Plugin initialization failed", "ERROR".red()); + return; + } + + // Get invoke function + let invoke_fn: Symbol i32> = + match library.get(b"nyash_plugin_invoke") { + Ok(f) => f, + Err(e) => { + eprintln!("{}: nyash_plugin_invoke not found: {}", "ERROR".red(), e); + return; + } + }; + + // Determine type_id + let type_id = if let Some(ref box_name) = box_type { + // For multi-box plugins, resolve type_id from name + if let Ok(get_type_id_fn) = library.get:: u32>>(b"nyash_plugin_get_type_id") { + let c_name = CString::new(box_name.as_str()).unwrap(); + let id = get_type_id_fn(c_name.as_ptr()); + if id == 0 { + eprintln!("{}: Box type '{}' not found", "ERROR".red(), box_name); + return; + } + id + } else { + eprintln!("{}: Multi-box plugin doesn't support type name resolution", "ERROR".red()); + return; + } + } else { + plugin_info.type_id + }; + + println!("Testing lifecycle for type_id: {}", type_id); + + // Test birth + println!("\n{}", "1. Testing birth (constructor)...".cyan()); + + let mut result_buf = vec![0u8; 1024]; + let mut result_len = result_buf.len(); + + let result = invoke_fn( + type_id, + 0, // METHOD_BIRTH + 0, // instance_id = 0 for birth + std::ptr::null(), + 0, + result_buf.as_mut_ptr(), + &mut result_len + ); + + if result != 0 { + eprintln!("{}: Birth failed with code {}", "ERROR".red(), result); + return; + } + + // Parse instance_id from result + let instance_id = if result_len >= 4 { + u32::from_le_bytes([result_buf[0], result_buf[1], result_buf[2], result_buf[3]]) + } else { + eprintln!("{}: Invalid birth response", "ERROR".red()); + return; + }; + + println!("{}: Birth successful, instance_id = {}", "✓".green(), instance_id); + + // Test a method if FileBox + if plugin_info.type_name != std::ptr::null() { + let box_name = CStr::from_ptr(plugin_info.type_name).to_string_lossy(); + if box_name == "FileBox" { + test_file_operations(&invoke_fn, type_id, instance_id); + } + } + + // Test fini + println!("\n{}", "2. Testing fini (destructor)...".cyan()); + + result_len = result_buf.len(); + let result = invoke_fn( + type_id, + u32::MAX, // METHOD_FINI + instance_id, + std::ptr::null(), + 0, + result_buf.as_mut_ptr(), + &mut result_len + ); + + if result != 0 { + eprintln!("{}: Fini failed with code {}", "ERROR".red(), result); + } else { + println!("{}: Fini successful", "✓".green()); + } + } + + println!("\n{}", "Lifecycle test completed!".green().bold()); +} + +fn test_file_operations( + invoke_fn: &Symbol i32>, + type_id: u32, + instance_id: u32 +) { + println!("\n{}", "Testing file operations...".cyan()); + + // Test open + let mut args = Vec::new(); + tlv_encode_two_strings("test_lifecycle.txt", "w", &mut args); + + let mut result_buf = vec![0u8; 1024]; + let mut result_len = result_buf.len(); + + unsafe { + let result = invoke_fn( + type_id, + 1, // METHOD_OPEN + instance_id, + args.as_ptr(), + args.len(), + result_buf.as_mut_ptr(), + &mut result_len + ); + + if result == 0 { + println!("{}: Open successful", "✓".green()); + } else { + eprintln!("{}: Open failed", "ERROR".red()); + } + } +} + +fn test_file_io(path: &PathBuf) { + println!("{}", "=== File I/O Test ===".bold()); + println!("(Full I/O test implementation omitted for brevity)"); + println!("Use lifecycle test with FileBox for basic I/O testing"); +} + +fn test_tlv_debug(plugin: &Option, message: &str) { + println!("{}", "=== TLV Debug ===".bold()); + + // Encode string + let mut encoded = Vec::new(); + tlv_encode_string(message, &mut encoded); + + println!("Original message: {}", message.cyan()); + println!("Encoded bytes ({} bytes):", encoded.len()); + + // Display hex dump + for (i, chunk) in encoded.chunks(16).enumerate() { + print!("{:04x}: ", i * 16); + for byte in chunk { + print!("{:02x} ", byte); + } + println!(); + } + + // Decode header + if encoded.len() >= 4 { + let version = u16::from_le_bytes([encoded[0], encoded[1]]); + let argc = u16::from_le_bytes([encoded[2], encoded[3]]); + println!("\nTLV Header:"); + println!(" Version: {}", version); + println!(" Arg count: {}", argc); + } +} + +fn typecheck_plugin(plugin_path: &PathBuf, config_path: &PathBuf) { + println!("{}", "=== Type Check ===".bold()); + + // Load nyash.toml + let config_content = match fs::read_to_string(config_path) { + Ok(content) => content, + Err(e) => { + eprintln!("{}: Failed to read config: {}", "ERROR".red(), e); + return; + } + }; + + let config_value: toml::Value = match toml::from_str(&config_content) { + Ok(val) => val, + Err(e) => { + eprintln!("{}: Failed to parse TOML: {}", "ERROR".red(), e); + return; + } + }; + + // Load plugin + let library = match unsafe { Library::new(plugin_path) } { + Ok(lib) => lib, + Err(e) => { + eprintln!("{}: Failed to load plugin: {}", "ERROR".red(), e); + return; + } + }; + + unsafe { + // Get plugin info + let init_fn: Symbol i32> = + match library.get(b"nyash_plugin_init") { + Ok(f) => f, + Err(_) => { + eprintln!("{}: Plugin doesn't export nyash_plugin_init", "ERROR".red()); + return; + } + }; + + let mut plugin_info = std::mem::zeroed::(); + let result = init_fn(&HOST_VTABLE, &mut plugin_info); + + if result != 0 { + eprintln!("{}: Plugin initialization failed", "ERROR".red()); return; } - // Get Box type name from plugin let box_name = if plugin_info.type_name.is_null() { - eprintln!("{}: Plugin did not provide type name", "ERROR".red()); + eprintln!("{}: Plugin doesn't provide type name", "ERROR".red()); return; } else { CStr::from_ptr(plugin_info.type_name).to_string_lossy().to_string() }; - println!("{}: Plugin Box type: {}", "✓".green(), box_name.cyan()); + println!("Plugin Box type: {}", box_name.cyan()); - // Validate type configuration - validate_type_configuration(&config, &box_name, &plugin_info); - - // Validate method signatures - validate_method_signatures(&config, &box_name, &plugin_info); - - // Check for duplicate method names (Nyash doesn't support overloading) - check_duplicate_methods(&plugin_info); - - // Shutdown plugin - if let Ok(shutdown_fn) = library.get::>(b"nyash_plugin_shutdown") { - shutdown_fn(); - println!("{}: Plugin shutdown completed", "✓".green()); - } - } - - println!("\n{}", "Type validation completed!".green().bold()); -} - -fn load_nyash_config(config_path: &PathBuf) -> Result> { - let config_content = fs::read_to_string(config_path)?; - let config: toml::Value = toml::from_str(&config_content)?; - - let mut plugin_map = HashMap::new(); - let mut plugin_configs = HashMap::new(); - - if let Some(config_table) = config.as_table() { - - // Parse [plugin_names] section (alternative structure) - if let Some(plugin_names) = config_table.get("plugin_names").and_then(|p| p.as_table()) { - for (box_type, plugin_name) in plugin_names { - if let Some(name) = plugin_name.as_str() { - plugin_map.insert(box_type.clone(), name.to_string()); - } - } - } - - // Parse [plugins] section for both mappings and nested configs - if let Some(plugins) = config_table.get("plugins").and_then(|p| p.as_table()) { - for (box_type, value) in plugins { - if let Some(name) = value.as_str() { - // Simple string mapping: FileBox = "plugin-name" - plugin_map.insert(box_type.clone(), name.to_string()); - } else if let Some(nested) = value.as_table() { - // Nested table structure: [plugins.FileBox] - if let Some(plugin_name) = nested.get("plugin_name").and_then(|n| n.as_str()) { - plugin_map.insert(box_type.clone(), plugin_name.to_string()); - } + // Check if box is configured in nyash.toml + if let Some(plugins) = config_value.get("plugins").and_then(|v| v.as_table()) { + if let Some(plugin_name) = plugins.get(&box_name).and_then(|v| v.as_str()) { + println!("{}: {} is configured as '{}'", "✓".green(), box_name, plugin_name); + + // Check method definitions + let methods_key = format!("plugins.{}.methods", box_name); + if let Some(methods) = config_value.get("plugins") + .and_then(|v| v.get(&box_name)) + .and_then(|v| v.get("methods")) + .and_then(|v| v.as_table()) { - if let Some(methods_table) = nested.get("methods").and_then(|m| m.as_table()) { - let method_configs = parse_methods_table(methods_table)?; - plugin_configs.insert( - format!("plugins.{}", box_type), - PluginConfig { methods: Some(method_configs) } - ); - } - } - } - } - - // Also handle the problematic current structure by manual parsing - // This is a workaround for the TOML structure issue - for (section_name, section_value) in config_table { - if section_name.starts_with("plugins.") && section_name.contains(".methods") { - if let Some(methods_table) = section_value.as_table() { - let box_type_part = section_name.replace("plugins.", "").replace(".methods", ""); - let method_configs = parse_methods_table(methods_table)?; - plugin_configs.insert( - format!("plugins.{}", box_type_part), - PluginConfig { methods: Some(method_configs) } - ); - } - } - } - } - - Ok(NyashConfig { - plugins: plugin_map, - plugin_configs, - }) -} - -fn parse_methods_table(methods_table: &toml::map::Map) -> Result, Box> { - let mut method_configs = HashMap::new(); - - for (method_name, method_value) in methods_table { - if let Some(method_table) = method_value.as_table() { - let mut args = Vec::new(); - let mut returns = None; - - // Parse args array - if let Some(args_array) = method_table.get("args").and_then(|v| v.as_array()) { - for arg_value in args_array { - if let Some(arg_table) = arg_value.as_table() { - let from = arg_table.get("from") - .and_then(|v| v.as_str()) - .unwrap_or("unknown") - .to_string(); - let to = arg_table.get("to") - .and_then(|v| v.as_str()) - .unwrap_or("unknown") - .to_string(); - let name = arg_table.get("name") - .and_then(|v| v.as_str()) - .map(|s| s.to_string()); - - args.push(TypeConversion { from, to, name }); - } - } - } - - // Parse returns field - if let Some(returns_str) = method_table.get("returns").and_then(|v| v.as_str()) { - returns = Some(returns_str.to_string()); - } - - method_configs.insert(method_name.clone(), MethodConfig { args, returns }); - } - } - - Ok(method_configs) -} - -fn validate_type_configuration(config: &NyashConfig, box_name: &str, plugin_info: &NyashPluginInfo) { - println!("\n{}", "--- Type Configuration Validation ---".cyan()); - - // Check if this Box type is configured in nyash.toml - if let Some(plugin_name) = config.plugins.get(box_name) { - println!("{}: Box type '{}' is configured to use plugin '{}'", - "✓".green(), box_name, plugin_name); - } else { - println!("{}: Box type '{}' is not configured in nyash.toml", - "WARNING".yellow(), box_name); - println!(" Consider adding: {} = \"plugin-name\"", box_name); - } - - // Check if method configuration exists - let config_key = format!("plugins.{}", box_name); - if let Some(plugin_config) = config.plugin_configs.get(&config_key) { - if let Some(methods) = &plugin_config.methods { - println!("{}: Found method configuration for {} methods", - "✓".green(), methods.len()); - } else { - println!("{}: No method configuration found for {}", - "WARNING".yellow(), box_name); - } - } else { - println!("{}: No method configuration section [plugins.{}.methods] found", - "WARNING".yellow(), box_name); - } -} - -fn validate_method_signatures(config: &NyashConfig, box_name: &str, plugin_info: &NyashPluginInfo) { - println!("\n{}", "--- Method Signature Validation ---".cyan()); - - if plugin_info.method_count == 0 || plugin_info.methods.is_null() { - println!("{}: Plugin has no methods to validate", "INFO".blue()); - return; - } - - let config_key = format!("plugins.{}", box_name); - let plugin_config = config.plugin_configs.get(&config_key); - let method_configs = plugin_config.and_then(|c| c.methods.as_ref()); - - unsafe { - let methods = std::slice::from_raw_parts(plugin_info.methods, plugin_info.method_count); - - for method in methods { - let method_name = if method.name.is_null() { - "".to_string() - } else { - CStr::from_ptr(method.name).to_string_lossy().to_string() - }; - - println!("Validating method: {}", method_name.cyan()); - - // Check if method is configured - if let Some(configs) = method_configs { - if let Some(method_config) = configs.get(&method_name) { - println!(" {}: Method configuration found", "✓".green()); + println!("\n{}", "Configured methods:".bold()); - // Validate argument types - if method_config.args.is_empty() { - println!(" {}: No arguments configured", "✓".green()); + // Get actual methods from plugin + let actual_methods = if plugin_info.method_count > 0 && !plugin_info.methods.is_null() { + let methods = std::slice::from_raw_parts(plugin_info.methods, plugin_info.method_count); + methods.iter() + .filter_map(|m| { + if m.name.is_null() { + None + } else { + Some(CStr::from_ptr(m.name).to_string_lossy().to_string()) + } + }) + .collect::>() } else { - println!(" {}: {} argument(s) configured", "✓".green(), method_config.args.len()); - for (i, arg) in method_config.args.iter().enumerate() { - println!(" Arg {}: {} → {}", i, arg.from, arg.to); - if let Some(name) = &arg.name { - println!(" Name: {}", name); - } + vec![] + }; + + for (method_name, _method_def) in methods { + let status = if actual_methods.contains(method_name) { + format!("{}", "✓".green()) + } else { + format!("{}", "✗".red()) + }; + println!(" {} {}", status, method_name); + } + + // Check for duplicate method names + let mut seen = std::collections::HashSet::new(); + for method in &actual_methods { + if !seen.insert(method) { + eprintln!("{}: Duplicate method name: {}", "WARNING".yellow(), method); + eprintln!(" Note: Nyash doesn't support function overloading"); } } - - // Validate return type - if let Some(returns) = &method_config.returns { - println!(" {}: Return type: {}", "✓".green(), returns); - } } else { - println!(" {}: Method not configured in nyash.toml", "WARNING".yellow()); - println!(" Consider adding configuration for method '{}'", method_name); + eprintln!("{}: No method definitions found for {}", "WARNING".yellow(), box_name); } } else { - println!(" {}: No method configurations available", "WARNING".yellow()); - } - } - } -} - -fn check_duplicate_methods(plugin_info: &NyashPluginInfo) { - println!("\n{}", "--- Duplicate Method Check ---".cyan()); - - if plugin_info.method_count == 0 || plugin_info.methods.is_null() { - println!("{}: Plugin has no methods to check", "INFO".blue()); - return; - } - - let mut method_names = HashMap::new(); - let mut duplicates_found = false; - - unsafe { - let methods = std::slice::from_raw_parts(plugin_info.methods, plugin_info.method_count); - - for method in methods { - let method_name = if method.name.is_null() { - "".to_string() - } else { - CStr::from_ptr(method.name).to_string_lossy().to_string() - }; - - if let Some(existing_id) = method_names.get(&method_name) { - println!("{}: Duplicate method name '{}' found!", "ERROR".red(), method_name); - println!(" Method ID {} and {} both use the same name", existing_id, method.method_id); - println!(" Nyash does not support function overloading"); - duplicates_found = true; - } else { - method_names.insert(method_name.clone(), method.method_id); - println!("{}: Method '{}' [ID: {}]", "✓".green(), method_name, method.method_id); + eprintln!("{}: {} is not configured in nyash.toml", "WARNING".yellow(), box_name); } } } - if duplicates_found { - println!("\n{}: Duplicate method names detected!", "ERROR".red()); - println!(" Please ensure all method names are unique in your plugin."); - } else { - println!("\n{}: No duplicate method names found", "✓".green()); - } -} + println!("\n{}", "Type check completed!".green().bold()); +} \ No newline at end of file