🔧 refactor: すべてのBoxをArc<Mutex>パターンで統一

CopilotのBox実装を私たちのArc<Mutex>パターンで統一:
- BufferBox: Arc<Mutex<Vec<u8>>>で内部可変性を実現
- FileBox: Arc<Mutex<File>>でファイルハンドル管理
- JSONBox: Arc<Mutex<Value>>でJSON値を保持
- HttpClientBox: Arc<Mutex<Client>>でHTTPクライアント管理
- StreamBox: Arc<Mutex>でストリームバッファと位置を管理
- RegexBox: Arc<Regex>で軽量ラッパー実装

各Boxに実用的なメソッドも追加:
- BufferBox: write, read, readAll, clear, length, append, slice
- FileBox: read, write, exists, delete, copy
- JSONBox: parse, stringify, get, set, has, keys
- HttpClientBox: get, post, put, delete, request
- StreamBox: write, read, position, length, reset
- RegexBox: test, find, findAll, replace, split

interpreterに新Box用のメソッド実行を追加:
- data_methods.rs: BufferBox, JSONBox, RegexBox
- network_methods.rs: HttpClientBox, StreamBox

これでコードベース全体が一貫性のあるArc<Mutex>パターンで統一されました!

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
Moe Charm
2025-08-10 13:03:42 +09:00
parent b745f5ffa2
commit 750543be7c
12 changed files with 989 additions and 110 deletions

View File

@ -8,6 +8,7 @@
use super::*;
use crate::ast::UnaryOperator;
use crate::boxes::{BufferBox, JSONBox, HttpClientBox, StreamBox, RegexBox};
// TODO: Fix NullBox import issue later
// use crate::NullBox;
@ -326,6 +327,11 @@ impl NyashInterpreter {
return self.execute_array_method(array_box, method, arguments);
}
// BufferBox method calls
if let Some(buffer_box) = obj_value.as_any().downcast_ref::<BufferBox>() {
return self.execute_buffer_method(buffer_box, method, arguments);
}
// FileBox method calls
if let Some(file_box) = obj_value.as_any().downcast_ref::<FileBox>() {
return self.execute_file_method(file_box, method, arguments);
@ -346,6 +352,26 @@ impl NyashInterpreter {
return self.execute_channel_method(channel_box, method, arguments);
}
// JSONBox method calls
if let Some(json_box) = obj_value.as_any().downcast_ref::<JSONBox>() {
return self.execute_json_method(json_box, method, arguments);
}
// HttpClientBox method calls
if let Some(http_box) = obj_value.as_any().downcast_ref::<HttpClientBox>() {
return self.execute_http_method(http_box, method, arguments);
}
// StreamBox method calls
if let Some(stream_box) = obj_value.as_any().downcast_ref::<StreamBox>() {
return self.execute_stream_method(stream_box, method, arguments);
}
// RegexBox method calls
if let Some(regex_box) = obj_value.as_any().downcast_ref::<RegexBox>() {
return self.execute_regex_method(regex_box, method, arguments);
}
// MathBox method calls
if let Some(math_box) = obj_value.as_any().downcast_ref::<MathBox>() {
return self.execute_math_method(math_box, method, arguments);

View File

@ -0,0 +1,204 @@
/*!
* Data Processing Box Methods Module
*
* Contains method implementations for data processing Box types:
* - BufferBox (execute_buffer_method) - Binary data operations
* - JSONBox (execute_json_method) - JSON parsing and manipulation
* - RegexBox (execute_regex_method) - Regular expression operations
*/
use super::super::*;
use crate::box_trait::{NyashBox, StringBox, IntegerBox};
use crate::boxes::{BufferBox, JSONBox, RegexBox};
impl NyashInterpreter {
/// BufferBoxのメソッド呼び出しを実行
pub(in crate::interpreter) fn execute_buffer_method(&mut self, buffer_box: &BufferBox, method: &str, arguments: &[ASTNode])
-> Result<Box<dyn NyashBox>, RuntimeError> {
match method {
"write" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("write() expects 1 argument, got {}", arguments.len()),
});
}
let data = self.execute_expression(&arguments[0])?;
Ok(buffer_box.write(data))
}
"readAll" => {
if !arguments.is_empty() {
return Err(RuntimeError::InvalidOperation {
message: format!("readAll() expects 0 arguments, got {}", arguments.len()),
});
}
Ok(buffer_box.readAll())
}
"read" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("read() expects 1 argument, got {}", arguments.len()),
});
}
let count = self.execute_expression(&arguments[0])?;
Ok(buffer_box.read(count))
}
"clear" => {
if !arguments.is_empty() {
return Err(RuntimeError::InvalidOperation {
message: format!("clear() expects 0 arguments, got {}", arguments.len()),
});
}
Ok(buffer_box.clear())
}
"length" => {
if !arguments.is_empty() {
return Err(RuntimeError::InvalidOperation {
message: format!("length() expects 0 arguments, got {}", arguments.len()),
});
}
Ok(buffer_box.length())
}
"append" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("append() expects 1 argument, got {}", arguments.len()),
});
}
let other = self.execute_expression(&arguments[0])?;
Ok(buffer_box.append(other))
}
"slice" => {
if arguments.len() != 2 {
return Err(RuntimeError::InvalidOperation {
message: format!("slice() expects 2 arguments, got {}", arguments.len()),
});
}
let start = self.execute_expression(&arguments[0])?;
let end = self.execute_expression(&arguments[1])?;
Ok(buffer_box.slice(start, end))
}
_ => Err(RuntimeError::InvalidOperation {
message: format!("Unknown method '{}' for BufferBox", method),
})
}
}
/// JSONBoxのメソッド呼び出しを実行
pub(in crate::interpreter) fn execute_json_method(&mut self, json_box: &JSONBox, method: &str, arguments: &[ASTNode])
-> Result<Box<dyn NyashBox>, RuntimeError> {
match method {
"parse" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("parse() expects 1 argument, got {}", arguments.len()),
});
}
let data = self.execute_expression(&arguments[0])?;
Ok(JSONBox::parse(data))
}
"stringify" => {
if !arguments.is_empty() {
return Err(RuntimeError::InvalidOperation {
message: format!("stringify() expects 0 arguments, got {}", arguments.len()),
});
}
Ok(json_box.stringify())
}
"get" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("get() expects 1 argument, got {}", arguments.len()),
});
}
let key = self.execute_expression(&arguments[0])?;
Ok(json_box.get(key))
}
"set" => {
if arguments.len() != 2 {
return Err(RuntimeError::InvalidOperation {
message: format!("set() expects 2 arguments, got {}", arguments.len()),
});
}
let key = self.execute_expression(&arguments[0])?;
let value = self.execute_expression(&arguments[1])?;
Ok(json_box.set(key, value))
}
"has" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("has() expects 1 argument, got {}", arguments.len()),
});
}
let key = self.execute_expression(&arguments[0])?;
Ok(json_box.has(key))
}
"keys" => {
if !arguments.is_empty() {
return Err(RuntimeError::InvalidOperation {
message: format!("keys() expects 0 arguments, got {}", arguments.len()),
});
}
Ok(json_box.keys())
}
_ => Err(RuntimeError::InvalidOperation {
message: format!("Unknown method '{}' for JSONBox", method),
})
}
}
/// RegexBoxのメソッド呼び出しを実行
pub(in crate::interpreter) fn execute_regex_method(&mut self, regex_box: &RegexBox, method: &str, arguments: &[ASTNode])
-> Result<Box<dyn NyashBox>, RuntimeError> {
match method {
"test" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("test() expects 1 argument, got {}", arguments.len()),
});
}
let text = self.execute_expression(&arguments[0])?;
Ok(regex_box.test(text))
}
"find" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("find() expects 1 argument, got {}", arguments.len()),
});
}
let text = self.execute_expression(&arguments[0])?;
Ok(regex_box.find(text))
}
"findAll" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("findAll() expects 1 argument, got {}", arguments.len()),
});
}
let text = self.execute_expression(&arguments[0])?;
Ok(regex_box.find_all(text))
}
"replace" => {
if arguments.len() != 2 {
return Err(RuntimeError::InvalidOperation {
message: format!("replace() expects 2 arguments, got {}", arguments.len()),
});
}
let text = self.execute_expression(&arguments[0])?;
let replacement = self.execute_expression(&arguments[1])?;
Ok(regex_box.replace(text, replacement))
}
"split" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("split() expects 1 argument, got {}", arguments.len()),
});
}
let text = self.execute_expression(&arguments[0])?;
Ok(regex_box.split(text))
}
_ => Err(RuntimeError::InvalidOperation {
message: format!("Unknown method '{}' for RegexBox", method),
})
}
}
}

View File

@ -19,8 +19,12 @@
pub mod basic_methods; // StringBox, IntegerBox, BoolBox, FloatBox
pub mod collection_methods; // ArrayBox, MapBox
pub mod io_methods; // FileBox, ResultBox
pub mod data_methods; // BufferBox, JSONBox, RegexBox
pub mod network_methods; // HttpClientBox, StreamBox
// Re-export methods for easy access
pub use basic_methods::*;
pub use collection_methods::*;
pub use io_methods::*;
pub use io_methods::*;
pub use data_methods::*;
pub use network_methods::*;

View File

@ -0,0 +1,124 @@
/*!
* Network and Communication Box Methods Module
*
* Contains method implementations for network-related Box types:
* - HttpClientBox (execute_http_method) - HTTP client operations
* - StreamBox (execute_stream_method) - Stream processing operations
*/
use super::super::*;
use crate::box_trait::{NyashBox, StringBox};
use crate::boxes::{HttpClientBox, StreamBox};
impl NyashInterpreter {
/// HttpClientBoxのメソッド呼び出しを実行
pub(in crate::interpreter) fn execute_http_method(&mut self, http_box: &HttpClientBox, method: &str, arguments: &[ASTNode])
-> Result<Box<dyn NyashBox>, RuntimeError> {
match method {
"get" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("get() expects 1 argument, got {}", arguments.len()),
});
}
let url = self.execute_expression(&arguments[0])?;
Ok(http_box.http_get(url))
}
"post" => {
if arguments.len() != 2 {
return Err(RuntimeError::InvalidOperation {
message: format!("post() expects 2 arguments, got {}", arguments.len()),
});
}
let url = self.execute_expression(&arguments[0])?;
let body = self.execute_expression(&arguments[1])?;
Ok(http_box.post(url, body))
}
"put" => {
if arguments.len() != 2 {
return Err(RuntimeError::InvalidOperation {
message: format!("put() expects 2 arguments, got {}", arguments.len()),
});
}
let url = self.execute_expression(&arguments[0])?;
let body = self.execute_expression(&arguments[1])?;
Ok(http_box.put(url, body))
}
"delete" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("delete() expects 1 argument, got {}", arguments.len()),
});
}
let url = self.execute_expression(&arguments[0])?;
Ok(http_box.delete(url))
}
"request" => {
if arguments.len() != 3 {
return Err(RuntimeError::InvalidOperation {
message: format!("request() expects 3 arguments, got {}", arguments.len()),
});
}
let method_arg = self.execute_expression(&arguments[0])?;
let url = self.execute_expression(&arguments[1])?;
let options = self.execute_expression(&arguments[2])?;
Ok(http_box.request(method_arg, url, options))
}
_ => Err(RuntimeError::InvalidOperation {
message: format!("Unknown method '{}' for HttpClientBox", method),
})
}
}
/// StreamBoxのメソッド呼び出しを実行
pub(in crate::interpreter) fn execute_stream_method(&mut self, stream_box: &StreamBox, method: &str, arguments: &[ASTNode])
-> Result<Box<dyn NyashBox>, RuntimeError> {
match method {
"write" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("write() expects 1 argument, got {}", arguments.len()),
});
}
let data = self.execute_expression(&arguments[0])?;
Ok(stream_box.stream_write(data))
}
"read" => {
if arguments.len() != 1 {
return Err(RuntimeError::InvalidOperation {
message: format!("read() expects 1 argument, got {}", arguments.len()),
});
}
let count = self.execute_expression(&arguments[0])?;
Ok(stream_box.stream_read(count))
}
"position" => {
if !arguments.is_empty() {
return Err(RuntimeError::InvalidOperation {
message: format!("position() expects 0 arguments, got {}", arguments.len()),
});
}
Ok(stream_box.get_position())
}
"length" => {
if !arguments.is_empty() {
return Err(RuntimeError::InvalidOperation {
message: format!("length() expects 0 arguments, got {}", arguments.len()),
});
}
Ok(stream_box.get_length())
}
"reset" => {
if !arguments.is_empty() {
return Err(RuntimeError::InvalidOperation {
message: format!("reset() expects 0 arguments, got {}", arguments.len()),
});
}
Ok(stream_box.stream_reset())
}
_ => Err(RuntimeError::InvalidOperation {
message: format!("Unknown method '{}' for StreamBox", method),
})
}
}
}