rufio 0.33.0 → 0.34.0

data/lib_zig/rufio_native/src/main.zig

@@ -1,167 +1,378 @@
 const std = @import("std");
 const c = @cImport({
-    @cInclude("ruby.h");
     @cInclude("dirent.h");
     @cInclude("sys/stat.h");
     @cInclude("string.h");
-    @cInclude("time.h");
+    @cInclude("stdlib.h");
+    @cInclude("pthread.h");
 });
 
-/// ディレクトリエントリ情報
+/// スキャン状態
+pub const ScanState = enum(u8) {
+    idle = 0,
+    scanning = 1,
+    done = 2,
+    cancelled = 3,
+    failed = 4,
+};
+
+/// ディレクトリエントリ情報（内部保持用）
 const DirEntry = struct {
-    name: []const u8,
+    name: []u8,
     is_dir: bool,
     size: u64,
     mtime: i64,
     executable: bool,
     hidden: bool,
+
+    fn deinit(self: *DirEntry) void {
+        c.free(self.name.ptr);
+    }
 };
 
-/// ディレクトリをスキャンしてRuby配列を返す
-fn scanDirectory(self: c.VALUE, path_value: c.VALUE) callconv(.c) c.VALUE {
-    _ = self;
-
-    // パス文字列を取得
-    var mutable_path = path_value;
-    const path_str = c.rb_string_value_cstr(@ptrCast(&mutable_path));
-    const path_len = c.strlen(path_str);
-    const path = path_str[0..path_len];
-
-    // ディレクトリを開く
-    const dir = c.opendir(path_str) orelse {
-        c.rb_raise(c.rb_eRuntimeError, "Failed to open directory");
-        return c.Qnil;
-    };
-    defer _ = c.closedir(dir);
-
-    // Ruby配列を作成
-    const ary = c.rb_ary_new();
-
-    // ディレクトリエントリを読み取り
-    while (c.readdir(dir)) |entry| {
-        const name_ptr = @as([*:0]const u8, @ptrCast(&entry.*.d_name));
-        const name_len = c.strlen(name_ptr);
-        const name = name_ptr[0..name_len];
-
-        // "." と ".." をスキップ
-        if (std.mem.eql(u8, name, ".") or std.mem.eql(u8, name, "..")) {
-            continue;
+/// 非同期スキャナーコア（状態を保持）
+const AsyncScanner = struct {
+    entries: []DirEntry,
+    capacity: usize,
+    count: usize,
+    state: ScanState,
+    progress: usize,
+    total_estimate: usize,
+    mutex: c.pthread_mutex_t,
+    path_copy: ?[*:0]u8,
+    max_entries: usize,
+    thread: c.pthread_t,
+    thread_started: bool,
+
+    fn init() !*AsyncScanner {
+        const self = @as(?*AsyncScanner, @ptrCast(@alignCast(c.malloc(@sizeOf(AsyncScanner))))) orelse return error.OutOfMemory;
+
+        self.*.capacity = 64;
+        const entries_size = self.*.capacity * @sizeOf(DirEntry);
+        const entries_ptr = c.malloc(entries_size) orelse {
+            c.free(self);
+            return error.OutOfMemory;
+        };
+        self.*.entries = @as([*]DirEntry, @ptrCast(@alignCast(entries_ptr)))[0..self.*.capacity];
+        self.*.count = 0;
+        self.*.state = .idle;
+        self.*.progress = 0;
+        self.*.total_estimate = 0;
+        self.*.path_copy = null;
+        self.*.max_entries = 0;
+        self.*.thread_started = false;
+
+        // mutex初期化
+        _ = c.pthread_mutex_init(&self.*.mutex, null);
+
+        return self;
+    }
+
+    fn deinit(self: *AsyncScanner) void {
+        // スレッドが実行中なら待機
+        if (self.thread_started) {
+            _ = c.pthread_join(self.thread, null);
         }
 
-        // フルパスを構築
-        var path_buf: [std.fs.max_path_bytes]u8 = undefined;
-        const full_path = std.fmt.bufPrintZ(&path_buf, "{s}/{s}", .{ path, name }) catch {
-            continue;
-        };
+        // 各エントリの名前を解放
+        for (self.entries[0..self.count]) |*entry| {
+            entry.deinit();
+        }
 
-        // ファイル情報を取得
-        var stat_buf: c.struct_stat = undefined;
-        if (c.lstat(full_path.ptr, &stat_buf) != 0) {
-            continue;
+        // パスのコピーを解放
+        if (self.path_copy) |path| {
+            c.free(path);
         }
 
-        // ディレクトリかどうか
-        const is_dir = (stat_buf.st_mode & c.S_IFMT) == c.S_IFDIR;
+        // エントリ配列を解放
+        c.free(self.entries.ptr);
 
-        // 実行可能かどうか
-        const executable = (stat_buf.st_mode & c.S_IXUSR) != 0;
+        // mutex破棄
+        _ = c.pthread_mutex_destroy(&self.mutex);
 
-        // 隠しファイルかどうか
-        const hidden = name[0] == '.';
+        // 自身を解放
+        c.free(self);
+    }
 
-        // Rubyハッシュを作成
-        const hash = c.rb_hash_new();
+    fn clear(self: *AsyncScanner) void {
+        // 既存のエントリをクリア
+        for (self.entries[0..self.count]) |*entry| {
+            entry.deinit();
+        }
+        self.count = 0;
+        self.progress = 0;
+        self.total_estimate = 0;
+    }
 
-        // ハッシュにキーと値を設定
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("name")), c.rb_str_new(name.ptr, @intCast(name.len)));
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("is_dir")), if (is_dir) c.Qtrue else c.Qfalse);
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("size")), c.ULL2NUM(@as(c_ulonglong, @intCast(stat_buf.st_size))));
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("mtime")), c.LL2NUM(@as(c_longlong, @intCast(stat_buf.st_mtimespec.tv_sec))));
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("executable")), if (executable) c.Qtrue else c.Qfalse);
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("hidden")), if (hidden) c.Qtrue else c.Qfalse);
+    fn ensureCapacity(self: *AsyncScanner, needed: usize) !void {
+        if (needed <= self.capacity) return;
 
-        // 配列に追加
-        _ = c.rb_ary_push(ary, hash);
+        const new_capacity = @max(needed, self.capacity * 2);
+        const new_size = new_capacity * @sizeOf(DirEntry);
+        const new_ptr = c.realloc(self.entries.ptr, new_size) orelse return error.OutOfMemory;
+        self.entries = @as([*]DirEntry, @ptrCast(@alignCast(new_ptr)))[0..new_capacity];
+        self.capacity = new_capacity;
     }
 
-    return ary;
-}
+    fn isCancelled(self: *AsyncScanner) bool {
+        _ = c.pthread_mutex_lock(&self.mutex);
+        defer _ = c.pthread_mutex_unlock(&self.mutex);
+        return self.state == .cancelled;
+    }
 
-/// 高速スキャン（エントリ数制限付き）
-fn scanDirectoryFast(self: c.VALUE, path_value: c.VALUE, max_entries_value: c.VALUE) callconv(.c) c.VALUE {
-    _ = self;
+    fn setState(self: *AsyncScanner, new_state: ScanState) void {
+        _ = c.pthread_mutex_lock(&self.mutex);
+        defer _ = c.pthread_mutex_unlock(&self.mutex);
+        self.state = new_state;
+    }
+
+    fn scan(self: *AsyncScanner, path: [*:0]const u8, max_entries: usize) !void {
+        // クリア
+        self.clear();
+
+        const dir = c.opendir(path) orelse return error.CannotOpenDir;
+        defer _ = c.closedir(dir);
+
+        const path_len = c.strlen(path);
+        const path_slice = path[0..path_len];
+
+        while (c.readdir(dir)) |entry| {
+            // キャンセルチェック
+            if (self.isCancelled()) {
+                return error.Cancelled;
+            }
+
+            // エントリ数制限チェック
+            if (max_entries > 0 and self.count >= max_entries) break;
+
+            const name_ptr = @as([*:0]const u8, @ptrCast(&entry.*.d_name));
+            const name_len = c.strlen(name_ptr);
+            const name_slice = name_ptr[0..name_len];
+
+            // "." と ".." をスキップ
+            if (std.mem.eql(u8, name_slice, ".") or std.mem.eql(u8, name_slice, "..")) {
+                continue;
+            }
+
+            // 容量確保
+            try self.ensureCapacity(self.count + 1);
+
+            // フルパスを構築
+            var path_buf: [std.fs.max_path_bytes]u8 = undefined;
+            const full_path = std.fmt.bufPrintZ(&path_buf, "{s}/{s}", .{ path_slice, name_slice }) catch continue;
+
+            // ファイル情報を取得
+            var stat_buf: c.struct_stat = undefined;
+            if (c.lstat(full_path.ptr, &stat_buf) != 0) {
+                continue;
+            }
+
+            // 名前をコピー
+            const name_copy_ptr = c.malloc(name_len + 1) orelse return error.OutOfMemory;
+            const name_copy_bytes = @as([*]u8, @ptrCast(@alignCast(name_copy_ptr)));
+            const name_copy = name_copy_bytes[0..name_len];
+            @memcpy(name_copy, name_slice);
+            name_copy_bytes[name_len] = 0;
+
+            // エントリを追加
+            self.entries[self.count] = DirEntry{
+                .name = name_copy,
+                .is_dir = (stat_buf.st_mode & c.S_IFMT) == c.S_IFDIR,
+                .size = @intCast(stat_buf.st_size),
+                .mtime = @intCast(stat_buf.st_mtimespec.tv_sec),
+                .executable = (stat_buf.st_mode & c.S_IXUSR) != 0,
+                .hidden = name_slice[0] == '.',
+            };
+            self.count += 1;
+
+            // 進捗更新
+            _ = c.pthread_mutex_lock(&self.mutex);
+            self.progress = self.count;
+            _ = c.pthread_mutex_unlock(&self.mutex);
+        }
+    }
 
-    const max_entries = @as(usize, @intCast(c.NUM2INT(max_entries_value)));
-    var mutable_path = path_value;
-    const path_str = c.rb_string_value_cstr(@ptrCast(&mutable_path));
-    const path_len = c.strlen(path_str);
-    const path = path_str[0..path_len];
+    fn scanAsync(self: *AsyncScanner, path: [*:0]const u8, max_entries: usize) !void {
+        _ = c.pthread_mutex_lock(&self.mutex);
+        defer _ = c.pthread_mutex_unlock(&self.mutex);
 
-    const dir = c.opendir(path_str) orelse {
-        c.rb_raise(c.rb_eRuntimeError, "Failed to open directory");
-        return c.Qnil;
-    };
-    defer _ = c.closedir(dir);
+        if (self.state == .scanning) {
+            return error.AlreadyScanning;
+        }
 
-    const ary = c.rb_ary_new();
-    var count: usize = 0;
+        // パスをコピー
+        const path_len = c.strlen(path);
+        const path_copy_ptr = c.malloc(path_len + 1) orelse return error.OutOfMemory;
+        const path_copy_bytes = @as([*:0]u8, @ptrCast(@alignCast(path_copy_ptr)));
+        @memcpy(path_copy_bytes[0..path_len], path[0..path_len]);
+        path_copy_bytes[path_len] = 0;
 
-    while (c.readdir(dir)) |entry| {
-        if (count >= max_entries) break;
+        // 古いパスを解放
+        if (self.path_copy) |old_path| {
+            c.free(old_path);
+        }
 
-        const name_ptr = @as([*:0]const u8, @ptrCast(&entry.*.d_name));
-        const name_len = c.strlen(name_ptr);
-        const name = name_ptr[0..name_len];
+        self.path_copy = path_copy_bytes;
+        self.max_entries = max_entries;
+        self.state = .scanning;
 
-        if (std.mem.eql(u8, name, ".") or std.mem.eql(u8, name, "..")) {
-            continue;
+        // スレッド開始
+        const result = c.pthread_create(&self.thread, null, scanWorkerEntry, self);
+        if (result != 0) {
+            self.state = .failed;
+            return error.ThreadCreateFailed;
         }
+        self.thread_started = true;
+    }
 
-        var path_buf: [std.fs.max_path_bytes]u8 = undefined;
-        const full_path = std.fmt.bufPrintZ(&path_buf, "{s}/{s}", .{ path, name }) catch {
-            continue;
+    fn scanWorker(self: *AsyncScanner) void {
+        const path = self.path_copy orelse {
+            self.setState(.failed);
+            return;
         };
 
-        var stat_buf: c.struct_stat = undefined;
-        if (c.lstat(full_path.ptr, &stat_buf) != 0) {
-            continue;
-        }
+        self.scan(path, self.max_entries) catch |err| {
+            // キャンセルエラーの場合は状態を変更しない（既にcancelledになっている）
+            if (err == error.Cancelled) {
+                return;
+            }
+            self.setState(.failed);
+            return;
+        };
+
+        self.setState(.done);
+    }
+};
+
+// スレッドエントリポイント
+fn scanWorkerEntry(arg: ?*anyopaque) callconv(.c) ?*anyopaque {
+    const scanner = @as(*AsyncScanner, @ptrCast(@alignCast(arg)));
+    scanner.scanWorker();
+    return null;
+}
+
+// ============================================================
+// ABI Boundary: Ruby ABI非依存・ハンドルベース
+// ============================================================
 
-        const is_dir = (stat_buf.st_mode & c.S_IFMT) == c.S_IFDIR;
-        const executable = (stat_buf.st_mode & c.S_IXUSR) != 0;
-        const hidden = name[0] == '.';
+/// 非同期スキャナーを作成（ハンドル返却）
+export fn core_async_create() u64 {
+    const scanner = AsyncScanner.init() catch return 0;
+    return @intFromPtr(scanner);
+}
+
+/// 非同期スキャン開始
+export fn core_async_scan(handle: u64, path: [*:0]const u8) i32 {
+    if (handle == 0) return -1;
+
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    scanner.scanAsync(path, 0) catch return -1;
+    return 0;
+}
+
+/// 高速スキャン（エントリ数制限付き）
+export fn core_async_scan_fast(handle: u64, path: [*:0]const u8, max_entries: usize) i32 {
+    if (handle == 0) return -1;
+
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    scanner.scanAsync(path, max_entries) catch return -1;
+    return 0;
+}
 
-        const hash = c.rb_hash_new();
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("name")), c.rb_str_new(name.ptr, @intCast(name.len)));
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("is_dir")), if (is_dir) c.Qtrue else c.Qfalse);
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("size")), c.ULL2NUM(@as(c_ulonglong, @intCast(stat_buf.st_size))));
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("mtime")), c.LL2NUM(@as(c_longlong, @intCast(stat_buf.st_mtimespec.tv_sec))));
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("executable")), if (executable) c.Qtrue else c.Qfalse);
-        _ = c.rb_hash_aset(hash, c.ID2SYM(c.rb_intern("hidden")), if (hidden) c.Qtrue else c.Qfalse);
+/// 状態取得
+export fn core_async_get_state(handle: u64) u8 {
+    if (handle == 0) return @intFromEnum(ScanState.failed);
 
-        _ = c.rb_ary_push(ary, hash);
-        count += 1;
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    _ = c.pthread_mutex_lock(&scanner.mutex);
+    defer _ = c.pthread_mutex_unlock(&scanner.mutex);
+    return @intFromEnum(scanner.state);
+}
+
+/// 進捗取得
+export fn core_async_get_progress(handle: u64, current: *usize, total: *usize) void {
+    if (handle == 0) {
+        current.* = 0;
+        total.* = 0;
+        return;
     }
 
-    return ary;
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    _ = c.pthread_mutex_lock(&scanner.mutex);
+    defer _ = c.pthread_mutex_unlock(&scanner.mutex);
+
+    current.* = scanner.progress;
+    total.* = scanner.total_estimate;
 }
 
-/// バージョン情報
-fn getVersion(_: c.VALUE) callconv(.c) c.VALUE {
-    const version = "1.0.0-zig";
-    return c.rb_str_new(version.ptr, @intCast(version.len));
+/// キャンセル
+export fn core_async_cancel(handle: u64) void {
+    if (handle == 0) return;
+
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    _ = c.pthread_mutex_lock(&scanner.mutex);
+    defer _ = c.pthread_mutex_unlock(&scanner.mutex);
+
+    if (scanner.state == .scanning) {
+        scanner.state = .cancelled;
+    }
 }
 
-/// Ruby拡張の初期化
-export fn Init_rufio_zig() void {
-    // Rufioモジュールを取得または作成
-    const rufio_module = c.rb_define_module("Rufio");
+/// エントリ数を取得
+export fn core_async_get_count(handle: u64) usize {
+    if (handle == 0) return 0;
 
-    // NativeScannerZigクラスを定義
-    const scanner_class = c.rb_define_class_under(rufio_module, "NativeScannerZig", c.rb_cObject);
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    _ = c.pthread_mutex_lock(&scanner.mutex);
+    defer _ = c.pthread_mutex_unlock(&scanner.mutex);
+    return scanner.count;
+}
+
+/// 指定インデックスのエントリ名を取得
+export fn core_async_get_name(handle: u64, index: usize, buf: [*]u8, buf_size: usize) usize {
+    if (handle == 0) return 0;
+
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    _ = c.pthread_mutex_lock(&scanner.mutex);
+    defer _ = c.pthread_mutex_unlock(&scanner.mutex);
+
+    if (index >= scanner.count) return 0;
+
+    const entry = &scanner.entries[index];
+    const copy_len = @min(entry.name.len, buf_size - 1);
+    @memcpy(buf[0..copy_len], entry.name[0..copy_len]);
+    buf[copy_len] = 0;
+    return copy_len;
+}
+
+/// 指定インデックスのエントリ属性を取得
+export fn core_async_get_attrs(handle: u64, index: usize, is_dir: *u8, size: *u64, mtime: *i64, executable: *u8, hidden: *u8) i32 {
+    if (handle == 0) return -1;
+
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    _ = c.pthread_mutex_lock(&scanner.mutex);
+    defer _ = c.pthread_mutex_unlock(&scanner.mutex);
 
-    // クラスメソッドを定義
-    c.rb_define_singleton_method(scanner_class, "scan_directory", @ptrCast(&scanDirectory), 1);
-    c.rb_define_singleton_method(scanner_class, "scan_directory_fast", @ptrCast(&scanDirectoryFast), 2);
-    c.rb_define_singleton_method(scanner_class, "version", @ptrCast(&getVersion), 0);
+    if (index >= scanner.count) return -1;
+
+    const entry = &scanner.entries[index];
+    is_dir.* = if (entry.is_dir) 1 else 0;
+    size.* = entry.size;
+    mtime.* = entry.mtime;
+    executable.* = if (entry.executable) 1 else 0;
+    hidden.* = if (entry.hidden) 1 else 0;
+    return 0;
+}
+
+/// スキャナーを破棄
+export fn core_async_destroy(handle: u64) void {
+    if (handle == 0) return;
+
+    const scanner = @as(*AsyncScanner, @ptrFromInt(handle));
+    scanner.deinit();
+}
+
+/// バージョン情報
+export fn core_async_version() [*:0]const u8 {
+    return "4.0.0-async";
 }