rufio 0.33.0 → 0.34.0

data/lib/rufio/native_scanner_zig.rb

@@ -1,9 +1,14 @@
 # frozen_string_literal: true
 
+require 'fiddle'
+require 'fiddle/import'
+
 module Rufio
-  # Zig拡張のラッパー
-  # FFIを使わずに直接Rubyオブジェクトとして扱える
-  module NativeScannerZigLoader
+  # Zig拡張の非同期FFI層
+  # Ruby側は「ハンドル（u64）だけ」を持つ
+  module NativeScannerZigFFI
+    extend Fiddle::Importer
+
     LIB_PATH = File.expand_path('native/rufio_zig.bundle', __dir__)
 
     @loaded = false
@@ -17,12 +22,24 @@ module Rufio
 
         if File.exist?(LIB_PATH)
           begin
-            # .bundleファイルを直接ロード
-            # 拡張子を外してrequireする
-            lib_path_without_ext = LIB_PATH.sub(/\.bundle$/, '')
-            require lib_path_without_ext
-            @available = defined?(Rufio::NativeScannerZig)
-          rescue LoadError => e
+            # 動的ライブラリをロード
+            dlload LIB_PATH
+
+            # ABI Boundary: Ruby ABI非依存のC関数（非同期版）
+            extern 'uint64_t core_async_create()'
+            extern 'int32_t core_async_scan(uint64_t, const char*)'
+            extern 'int32_t core_async_scan_fast(uint64_t, const char*, size_t)'
+            extern 'uint8_t core_async_get_state(uint64_t)'
+            extern 'void core_async_get_progress(uint64_t, void*, void*)'
+            extern 'void core_async_cancel(uint64_t)'
+            extern 'size_t core_async_get_count(uint64_t)'
+            extern 'size_t core_async_get_name(uint64_t, size_t, void*, size_t)'
+            extern 'int32_t core_async_get_attrs(uint64_t, size_t, void*, void*, void*, void*, void*)'
+            extern 'void core_async_destroy(uint64_t)'
+            extern 'char* core_async_version()'
+
+            @available = true
+          rescue StandardError => e
             warn "Failed to load zig extension: #{e.message}" if ENV['RUFIO_DEBUG']
             @available = false
           end
@@ -37,12 +54,150 @@ module Rufio
         load! unless @loaded
         @available
       end
+
+      # バージョン取得
+      def version
+        core_async_version.to_s
+      end
+    end
+  end
+
+  # 非同期スキャナークラス（ポーリングベース）
+  class NativeScannerZigCore
+    POLL_INTERVAL = 0.01 # 10ms
+
+    def initialize
+      @handle = NativeScannerZigFFI.core_async_create
+      raise StandardError, "Failed to create scanner" if @handle.zero?
+    end
+
+    # 非同期スキャン開始
+    def scan_async(path)
+      result = NativeScannerZigFFI.core_async_scan(@handle, path)
+      raise StandardError, "Failed to start scan" if result != 0
+      self
+    end
+
+    # 高速スキャン（エントリ数制限付き）
+    def scan_fast_async(path, max_entries)
+      result = NativeScannerZigFFI.core_async_scan_fast(@handle, path, max_entries)
+      raise StandardError, "Failed to start scan" if result != 0
+      self
+    end
+
+    # ポーリングして完了待ち
+    def wait(timeout: nil)
+      start_time = Time.now
+      loop do
+        state = get_state
+
+        case state
+        when :done
+          return get_results
+        when :failed
+          raise StandardError, "Scan failed"
+        when :cancelled
+          raise StandardError, "Scan cancelled"
+        end
+
+        if timeout && (Time.now - start_time) > timeout
+          raise StandardError, "Timeout"
+        end
+
+        sleep POLL_INTERVAL
+      end
+    end
+
+    # 進捗報告付きで完了待ち
+    def wait_with_progress(&block)
+      loop do
+        state = get_state
+        progress = get_progress
+
+        yield(progress[:current], progress[:total]) if block_given?
+
+        case state
+        when :done
+          return get_results
+        when :failed
+          raise StandardError, "Scan failed"
+        when :cancelled
+          raise StandardError, "Scan cancelled"
+        end
+
+        sleep POLL_INTERVAL
+      end
+    end
+
+    # 状態確認
+    def get_state
+      state_code = NativeScannerZigFFI.core_async_get_state(@handle)
+      [:idle, :scanning, :done, :cancelled, :failed][state_code] || :failed
+    end
+
+    # 進捗取得
+    def get_progress
+      current = Fiddle::Pointer.malloc(8)
+      total = Fiddle::Pointer.malloc(8)
+      NativeScannerZigFFI.core_async_get_progress(@handle, current, total)
+      {
+        current: current[0, 8].unpack1('Q'),
+        total: total[0, 8].unpack1('Q')
+      }
+    end
+
+    # キャンセル
+    def cancel
+      NativeScannerZigFFI.core_async_cancel(@handle)
+    end
+
+    # 結果取得（完了後）
+    def get_results
+      count = NativeScannerZigFFI.core_async_get_count(@handle)
+      entries = []
+      count.times { |i| entries << get_entry(i) }
+      entries
+    end
+
+    # スキャナーを明示的に破棄
+    def close
+      return if @handle.zero?
+
+      NativeScannerZigFFI.core_async_destroy(@handle)
+      @handle = 0
+    end
+
+    private
+
+    # 指定インデックスのエントリを取得
+    def get_entry(index)
+      # 名前を取得
+      name_buf = Fiddle::Pointer.malloc(256)
+      name_len = NativeScannerZigFFI.core_async_get_name(@handle, index, name_buf, 256)
+      name = name_buf[0, name_len].force_encoding('UTF-8')
+
+      # 属性を取得
+      is_dir = Fiddle::Pointer.malloc(1)
+      size = Fiddle::Pointer.malloc(8)
+      mtime = Fiddle::Pointer.malloc(8)
+      executable = Fiddle::Pointer.malloc(1)
+      hidden = Fiddle::Pointer.malloc(1)
+
+      NativeScannerZigFFI.core_async_get_attrs(@handle, index, is_dir, size, mtime, executable, hidden)
+
+      {
+        name: name,
+        is_dir: is_dir[0, 1].unpack1('C') != 0,
+        size: size[0, 8].unpack1('Q'),
+        mtime: mtime[0, 8].unpack1('q'),
+        executable: executable[0, 1].unpack1('C') != 0,
+        hidden: hidden[0, 1].unpack1('C') != 0
+      }
     end
   end
 
-  # Zig拡張が利用可能な場合のみロード
-  if NativeScannerZigLoader.load!
-    # NativeScannerにzigモードを追加
+  # Zig拡張が利用可能な場合のみ、NativeScannerに統合
+  if NativeScannerZigFFI.load!
     class NativeScanner
       class << self
         # zigモードを追加
@@ -51,9 +206,9 @@ module Rufio
         def mode=(value)
           case value
           when 'zig'
-            if NativeScannerZigLoader.available?
+            if NativeScannerZigFFI.available?
               @mode = 'zig'
-              @current_library = nil  # zig は FFI を使わない
+              @current_library = nil
             else
               @mode = 'ruby'
               @current_library = nil
@@ -63,44 +218,57 @@ module Rufio
           end
         end
 
-        # zigスキャン
+        # zigスキャン（ポーリング方式）
         def scan_directory_with_zig(path)
           raise StandardError, "Directory does not exist: #{path}" unless Dir.exist?(path)
 
-          entries = NativeScannerZig.scan_directory(path)
-
-          # 結果の形式を統一
-          entries.map do |entry|
-            {
-              name: entry[:name],
-              type: entry[:is_dir] ? 'directory' : 'file',
-              size: entry[:size],
-              mtime: entry[:mtime],
-              mode: 0,
-              executable: entry[:executable],
-              hidden: entry[:hidden]
-            }
+          # 非同期スキャナーを作成してスキャン
+          scanner = NativeScannerZigCore.new
+          begin
+            scanner.scan_async(path)
+            entries = scanner.wait(timeout: 60)
+
+            # 結果の形式を統一（type フィールドを追加）
+            entries.map do |entry|
+              {
+                name: entry[:name],
+                type: entry[:is_dir] ? 'directory' : 'file',
+                size: entry[:size],
+                mtime: entry[:mtime],
+                mode: 0,
+                executable: entry[:executable],
+                hidden: entry[:hidden]
+              }
+            end
+          ensure
+            scanner.close
           end
         rescue StandardError => e
           raise StandardError, "Zig scan failed: #{e.message}"
         end
 
-        # zigで高速スキャン
+        # zigで高速スキャン（ポーリング方式）
         def scan_directory_fast_with_zig(path, max_entries)
           raise StandardError, "Directory does not exist: #{path}" unless Dir.exist?(path)
 
-          entries = NativeScannerZig.scan_directory_fast(path, max_entries)
-
-          entries.map do |entry|
-            {
-              name: entry[:name],
-              type: entry[:is_dir] ? 'directory' : 'file',
-              size: entry[:size],
-              mtime: entry[:mtime],
-              mode: 0,
-              executable: entry[:executable],
-              hidden: entry[:hidden]
-            }
+          scanner = NativeScannerZigCore.new
+          begin
+            scanner.scan_fast_async(path, max_entries)
+            entries = scanner.wait(timeout: 60)
+
+            entries.map do |entry|
+              {
+                name: entry[:name],
+                type: entry[:is_dir] ? 'directory' : 'file',
+                size: entry[:size],
+                mtime: entry[:mtime],
+                mode: 0,
+                executable: entry[:executable],
+                hidden: entry[:hidden]
+              }
+            end
+          ensure
+            scanner.close
           end
         rescue StandardError => e
           raise StandardError, "Zig fast scan failed: #{e.message}"
@@ -115,13 +283,6 @@ module Rufio
           case @mode
           when 'zig'
             scan_directory_with_zig(path)
-          when 'magnus'
-            # magnusモードの場合は、native_scanner_magnus.rbで定義されたメソッドを呼ぶ
-            if defined?(NativeScannerMagnusLoader) && respond_to?(:scan_directory_with_magnus, true)
-              scan_directory_with_magnus(path)
-            else
-              original_scan_directory(path)
-            end
           else
             original_scan_directory(path)
           end
@@ -136,13 +297,6 @@ module Rufio
           case @mode
           when 'zig'
             scan_directory_fast_with_zig(path, max_entries)
-          when 'magnus'
-            # magnusモードの場合は、native_scanner_magnus.rbで定義されたメソッドを呼ぶ
-            if defined?(NativeScannerMagnusLoader) && respond_to?(:scan_directory_fast_with_magnus, true)
-              scan_directory_fast_with_magnus(path, max_entries)
-            else
-              original_scan_directory_fast(path, max_entries)
-            end
           else
             original_scan_directory_fast(path, max_entries)
           end
@@ -156,7 +310,7 @@ module Rufio
 
           case @mode
           when 'zig'
-            NativeScannerZig.version
+            NativeScannerZigFFI.version
           else
             original_version
           end
@@ -167,50 +321,29 @@ module Rufio
 
         def available_libraries
           original = original_available_libraries
-          result = original.merge(zig: NativeScannerZigLoader.available?)
-          # magnusが既に追加されていなければ追加
-          if defined?(NativeScannerMagnusLoader) && !result.key?(:magnus)
-            result = result.merge(magnus: NativeScannerMagnusLoader.available?)
-          end
-          result
+          original.merge(zig: NativeScannerZigFFI.available?)
         end
 
-        # autoモードの優先順位を更新（magnus > zig > rust > go > ruby）
+        # autoモードの優先順位を更新（zig > ruby）
         def mode=(value)
           case value
           when 'auto'
-            # 優先順位: Magnus > Zig > Rust > Go > Ruby
-            if defined?(NativeScannerMagnusLoader) && NativeScannerMagnusLoader.available?
-              @mode = 'magnus'
-              @current_library = nil
-            elsif NativeScannerZigLoader.available?
+            # 優先順位: Zig > Ruby
+            if NativeScannerZigFFI.available?
               @mode = 'zig'
               @current_library = nil
-            elsif defined?(RustLib) && RustLib.available?
-              @mode = 'rust'
-              @current_library = RustLib
-            elsif defined?(GoLib) && GoLib.available?
-              @mode = 'go'
-              @current_library = GoLib
             else
               @mode = 'ruby'
               @current_library = nil
             end
           when 'zig'
-            if NativeScannerZigLoader.available?
+            if NativeScannerZigFFI.available?
               @mode = 'zig'
               @current_library = nil
             else
               @mode = 'ruby'
               @current_library = nil
             end
-          when 'magnus'
-            if defined?(NativeScannerMagnusLoader) && NativeScannerMagnusLoader.available?
-              @mode = 'magnus'
-              @current_library = nil
-            else
-              send(:original_mode=, value)
-            end
           else
             send(:original_mode=, value)
           end

data/lib/rufio/parallel_scanner.rb

@@ -0,0 +1,173 @@
+# frozen_string_literal: true
+
+require 'thread'
+
+module Rufio
+  # 並列スキャン最適化クラス
+  #
+  # 複数のディレクトリを並列にスキャンし、結果をマージします。
+  # スレッドプールを使用して効率的に並列処理を行います。
+  #
+  # 使用例:
+  #   parallel_scanner = ParallelScanner.new(max_workers: 4)
+  #   results = parallel_scanner.scan_all(['/path1', '/path2', '/path3'])
+  #   all_entries = parallel_scanner.scan_all_merged(['/path1', '/path2'])
+  #
+  class ParallelScanner
+    DEFAULT_MAX_WORKERS = 4
+
+    # @param max_workers [Integer] 最大ワーカー数
+    # @param backend [Symbol] バックエンド (:ruby or :zig)
+    def initialize(max_workers: DEFAULT_MAX_WORKERS, backend: :ruby)
+      @max_workers = max_workers
+      @backend = backend
+    end
+
+    # 複数のディレクトリを並列スキャン
+    #
+    # @param paths [Array<String>] スキャンするディレクトリパスのリスト
+    # @return [Array<Hash>] 各ディレクトリのスキャン結果
+    #   [{path:, entries:, success:, error:}, ...]
+    def scan_all(paths)
+      return [] if paths.empty?
+
+      results = []
+      mutex = Mutex.new
+      queue = Queue.new
+
+      # キューにパスを追加
+      paths.each { |path| queue << path }
+
+      # ワーカースレッドを作成
+      workers = []
+      worker_count = [@max_workers, paths.length].min
+
+      worker_count.times do
+        workers << Thread.new do
+          loop do
+            path = queue.pop(true) rescue nil
+            break if path.nil?
+
+            result = scan_single_directory(path)
+            mutex.synchronize { results << result }
+          end
+        end
+      end
+
+      # 全ワーカーの完了を待つ
+      workers.each(&:join)
+
+      results
+    end
+
+    # 複数のディレクトリを並列スキャンし、結果をマージ
+    #
+    # @param paths [Array<String>] スキャンするディレクトリパスのリスト
+    # @yield [entry] 各エントリをフィルタリングするブロック（オプション）
+    # @return [Array<Hash>] 全エントリのマージされた配列
+    def scan_all_merged(paths, &filter)
+      results = scan_all(paths)
+
+      # 成功した結果のみを取得
+      all_entries = results
+        .select { |r| r[:success] }
+        .flat_map { |r| r[:entries] }
+
+      # フィルタが指定されている場合は適用
+      all_entries = all_entries.select(&filter) if block_given?
+
+      all_entries
+    end
+
+    # 進捗報告付き並列スキャン
+    #
+    # @param paths [Array<String>] スキャンするディレクトリパスのリスト
+    # @yield [completed, total] 進捗情報を受け取るブロック
+    # @return [Array<Hash>] 各ディレクトリのスキャン結果
+    def scan_all_with_progress(paths, &block)
+      return [] if paths.empty?
+
+      results = []
+      mutex = Mutex.new
+      queue = Queue.new
+      completed = 0
+      total = paths.length
+
+      # キューにパスを追加
+      paths.each { |path| queue << path }
+
+      # ワーカースレッドを作成
+      workers = []
+      worker_count = [@max_workers, paths.length].min
+
+      worker_count.times do
+        workers << Thread.new do
+          loop do
+            path = queue.pop(true) rescue nil
+            break if path.nil?
+
+            result = scan_single_directory(path)
+
+            mutex.synchronize do
+              results << result
+              completed += 1
+              yield(completed, total) if block_given?
+            end
+          end
+        end
+      end
+
+      # 全ワーカーの完了を待つ
+      workers.each(&:join)
+
+      results
+    end
+
+    private
+
+    # 単一のディレクトリをスキャン
+    #
+    # @param path [String] スキャンするディレクトリパス
+    # @return [Hash] スキャン結果 {path:, entries:, success:, error:}
+    def scan_single_directory(path)
+      scanner = create_scanner
+
+      begin
+        scanner.scan_async(path)
+        entries = scanner.wait(timeout: 60)
+
+        {
+          path: path,
+          entries: entries,
+          success: true
+        }
+      rescue StandardError => e
+        {
+          path: path,
+          entries: [],
+          success: false,
+          error: e.message
+        }
+      ensure
+        scanner.close
+      end
+    end
+
+    # バックエンドに応じたスキャナーを作成
+    #
+    # @return [NativeScannerRubyCore, NativeScannerZigCore] スキャナーインスタンス
+    def create_scanner
+      case @backend
+      when :zig
+        if defined?(NativeScannerZigFFI) && NativeScannerZigFFI.available?
+          NativeScannerZigCore.new
+        else
+          # Zigが利用できない場合はRubyにフォールバック
+          NativeScannerRubyCore.new
+        end
+      else
+        NativeScannerRubyCore.new
+      end
+    end
+  end
+end

data/lib/rufio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rufio
-  VERSION = '0.33.0'
+  VERSION = '0.34.0'
 end

data/lib/rufio.rb

@@ -33,8 +33,10 @@ require_relative "rufio/shell_command_completion"
 require_relative "rufio/command_logger"
 require_relative "rufio/background_command_executor"
 require_relative "rufio/native_scanner"
-require_relative "rufio/native_scanner_magnus"
 require_relative "rufio/native_scanner_zig"
+require_relative "rufio/async_scanner_promise"
+require_relative "rufio/async_scanner_fiber"
+require_relative "rufio/parallel_scanner"
 
 # プロジェクトモード
 require_relative "rufio/project_mode"

data/lib_zig/rufio_native/Makefile

@@ -7,13 +7,14 @@ ZIG := zig
 RUBY_INCLUDE := $(shell $(RUBY) -e "puts RbConfig::CONFIG['rubyhdrdir']")
 RUBY_ARCH_INCLUDE := $(shell $(RUBY) -e "puts RbConfig::CONFIG['rubyarchhdrdir']")
 RUBY_LIB_DIR := $(shell $(RUBY) -e "puts RbConfig::CONFIG['libdir']")
+RUBY_VERSION := $(shell $(RUBY) -e "puts RbConfig::CONFIG['MAJOR'] + '.' + RbConfig::CONFIG['MINOR']")
 
 # コンパイルフラグ
 ZIG_FLAGS := -O ReleaseFast -dynamic -lc
 ZIG_FLAGS += -I$(RUBY_INCLUDE)
 ZIG_FLAGS += -I$(RUBY_ARCH_INCLUDE)
 ZIG_FLAGS += -L$(RUBY_LIB_DIR)
-ZIG_FLAGS += -lruby.3.4
+ZIG_FLAGS += -lruby.$(RUBY_VERSION)
 
 # ターゲット
 TARGET := librufio_zig.dylib