rufio 1.0.4 → 1.3.0

data/lib/rufio/native_scanner.rb

@@ -17,69 +17,17 @@ module Rufio
 
     # 非同期スキャン開始
     def scan_async(path)
-      raise StandardError, "Directory does not exist: #{path}" unless Dir.exist?(path)
-      raise StandardError, "Scanner is already running" unless @state == :idle
-
-      @mutex.synchronize do
-        @state = :scanning
-        @results = []
-        @error = nil
-        @current_progress = 0
-        @total_progress = 0
-      end
-
-      @thread = Thread.new do
-        begin
-          # ディレクトリをスキャン
-          entries = []
-          Dir.foreach(path) do |entry|
-            next if entry == '.' || entry == '..'
-
-            # キャンセルチェック
-            break if @state == :cancelled
-
-            full_path = File.join(path, entry)
-            stat = File.lstat(full_path)
-
-            entries << {
-              name: entry,
-              type: file_type(stat),
-              size: stat.size,
-              mtime: stat.mtime.to_i,
-              mode: stat.mode,
-              executable: stat.executable?,
-              hidden: entry.start_with?('.')
-            }
-
-            # 進捗を更新
-            @mutex.synchronize do
-              @current_progress += 1
-              @total_progress = entries.length + 1
-            end
-          end
-
-          # 結果を保存
-          @mutex.synchronize do
-            if @state == :cancelled
-              @state = :cancelled
-            else
-              @results = entries
-              @state = :done
-            end
-          end
-        rescue StandardError => e
-          @mutex.synchronize do
-            @error = e
-            @state = :failed
-          end
-        end
-      end
-
-      self
+      start_scan_thread(path, nil)
     end
 
     # 高速スキャン（エントリ数制限付き）
     def scan_fast_async(path, max_entries)
+      start_scan_thread(path, max_entries)
+    end
+
+    private
+
+    def start_scan_thread(path, max_entries)
       raise StandardError, "Directory does not exist: #{path}" unless Dir.exist?(path)
       raise StandardError, "Scanner is already running" unless @state == :idle
 
@@ -88,7 +36,7 @@ module Rufio
         @results = []
         @error = nil
         @current_progress = 0
-        @total_progress = max_entries
+        @total_progress = max_entries || 0
       end
 
       @thread = Thread.new do
@@ -98,9 +46,7 @@ module Rufio
 
           Dir.foreach(path) do |entry|
             next if entry == '.' || entry == '..'
-            break if count >= max_entries
-
-            # キャンセルチェック
+            break if max_entries && count >= max_entries
             break if @state == :cancelled
 
             full_path = File.join(path, entry)
@@ -117,17 +63,14 @@ module Rufio
             }
             count += 1
 
-            # 進捗を更新
             @mutex.synchronize do
               @current_progress = count
+              @total_progress = entries.length + 1 unless max_entries
             end
           end
 
-          # 結果を保存
           @mutex.synchronize do
-            if @state == :cancelled
-              @state = :cancelled
-            else
+            if @state != :cancelled
               @results = entries
               @state = :done
             end
@@ -143,6 +86,8 @@ module Rufio
       self
     end
 
+    public
+
     # ポーリングして完了待ち
     def wait(timeout: nil)
       start_time = Time.now

data/lib/rufio/native_scanner_zig.rb

@@ -2,6 +2,7 @@
 
 require 'fiddle'
 require 'fiddle/import'
+require 'rbconfig'
 
 module Rufio
   # Zig拡張の非同期FFI層
@@ -9,21 +10,58 @@ module Rufio
   module NativeScannerZigFFI
     extend Fiddle::Importer
 
-    LIB_PATH = File.expand_path('native/rufio_zig.bundle', __dir__)
+    NATIVE_DIR = File.expand_path('native', __dir__)
+
+    # Gem に同梱するプラットフォーム（lib/rufio/native/<platform>/<file>）
+    PLATFORMS = {
+      'aarch64-macos' => 'librufio_zig.dylib',
+      'x86_64-macos' => 'librufio_zig.dylib',
+      'x86_64-linux-gnu' => 'librufio_zig.so',
+      'aarch64-linux-gnu' => 'librufio_zig.so',
+      'x86_64-linux-musl' => 'librufio_zig.so',
+      'aarch64-linux-musl' => 'librufio_zig.so',
+      'x86_64-windows' => 'rufio_zig.dll',
+      'aarch64-windows' => 'rufio_zig.dll'
+    }.freeze
 
     @loaded = false
     @available = false
+    @loaded_path = nil
 
     class << self
+      attr_reader :loaded_path
+
+      # RbConfig の host_os / host_cpu から同梱バイナリのディレクトリ名を決める（非対応なら nil）
+      def platform_dir(host_os = RbConfig::CONFIG['host_os'], host_cpu = RbConfig::CONFIG['host_cpu'])
+        cpu = case host_cpu.to_s
+              when /\A(arm64|aarch64)/i then 'aarch64'
+              when /\A(x86_64|x64|amd64)\z/i then 'x86_64'
+              end
+        return nil unless cpu
+
+        case host_os.to_s
+        when /darwin/ then "#{cpu}-macos"
+        when /linux/ then "#{cpu}-linux-#{host_os.to_s.include?('musl') ? 'musl' : 'gnu'}"
+        when /mingw|mswin/ then "#{cpu}-windows"
+        end
+      end
+
+      def library_path(host_os = RbConfig::CONFIG['host_os'], host_cpu = RbConfig::CONFIG['host_cpu'])
+        dir = platform_dir(host_os, host_cpu)
+        dir && File.join(NATIVE_DIR, dir, PLATFORMS.fetch(dir))
+      end
+
       def load!
         return @available if @loaded
 
         @loaded = true
+        path = library_path
 
-        if File.exist?(LIB_PATH)
+        if path && File.exist?(path)
           begin
             # 動的ライブラリをロード
-            dlload LIB_PATH
+            dlload path
+            @loaded_path = path
 
             # ABI Boundary: Ruby ABI非依存のC関数（非同期版）
             extern 'uint64_t core_async_create()'
@@ -39,6 +77,8 @@ module Rufio
             extern 'char* core_async_version()'
 
             @available = true
+            load_search_functions!
+            load_zip_functions!
           rescue StandardError => e
             warn "Failed to load zig extension: #{e.message}" if ENV['RUFIO_DEBUG']
             @available = false
@@ -55,10 +95,55 @@ module Rufio
         @available
       end
 
+      # コンテンツ検索 API（古いライブラリには存在しない）
+      def search_available?
+        load! unless @loaded
+        @search_available == true
+      end
+
+      # ZIP データ処理 API（古いライブラリには存在しない）
+      def zip_available?
+        load! unless @loaded
+        @zip_available == true
+      end
+
       # バージョン取得
       def version
         core_async_version.to_s
       end
+
+      private
+
+      def load_search_functions!
+        extern 'uint64_t core_search_create(const char*, size_t, const char*, size_t, const char*, size_t, const char*, size_t, uint32_t, uint64_t)'
+        extern 'uint8_t core_search_state(uint64_t)'
+        extern 'void* core_search_drain(uint64_t, void*)'
+        extern 'uint64_t core_search_skipped(uint64_t)'
+        extern 'void core_search_cancel(uint64_t)'
+        extern 'void core_search_destroy(uint64_t)'
+        extern 'uint64_t core_cache_create(uint64_t)'
+        extern 'uint64_t core_cache_bytes(uint64_t)'
+        extern 'void core_cache_destroy(uint64_t)'
+        @search_available = true
+      rescue Fiddle::DLError => e
+        warn "Zig content search unavailable: #{e.message}" if ENV['RUFIO_DEBUG']
+        @search_available = false
+      end
+
+      def load_zip_functions!
+        extern 'uint64_t core_zip_extract_create(const char*, size_t, const char*, size_t, uint32_t)'
+        extern 'uint64_t core_zip_deflate_create(const char*, size_t, int32_t, uint32_t)'
+        extern 'uint8_t core_zip_state(uint64_t)'
+        extern 'void core_zip_progress(uint64_t, void*, void*)'
+        extern 'uint8_t core_zip_status(uint64_t, size_t)'
+        extern 'uint8_t core_zip_deflate_result(uint64_t, size_t, void*, void*, void*)'
+        extern 'void core_zip_cancel(uint64_t)'
+        extern 'void core_zip_destroy(uint64_t)'
+        @zip_available = true
+      rescue Fiddle::DLError => e
+        warn "Zig ZIP engine unavailable: #{e.message}" if ENV['RUFIO_DEBUG']
+        @zip_available = false
+      end
     end
   end
 
@@ -200,12 +285,12 @@ module Rufio
   if NativeScannerZigFFI.load!
     class NativeScanner
       class << self
-        # zigモードを追加
+        # zigモードを追加（autoモードの優先順位: Zig > Ruby）
         alias_method :original_mode=, :mode= unless method_defined?(:original_mode=)
 
         def mode=(value)
           case value
-          when 'zig'
+          when 'auto', 'zig'
             if NativeScannerZigFFI.available?
               @mode = 'zig'
               @current_library = nil
@@ -214,7 +299,7 @@ module Rufio
               @current_library = nil
             end
           else
-            original_mode=(value)
+            send(:original_mode=, value)
           end
         end
 
@@ -222,24 +307,10 @@ module Rufio
         def scan_directory_with_zig(path)
           raise StandardError, "Directory does not exist: #{path}" unless Dir.exist?(path)
 
-          # 非同期スキャナーを作成してスキャン
           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
+            normalize_zig_entries(scanner.wait(timeout: 60))
           ensure
             scanner.close
           end
@@ -254,19 +325,7 @@ module Rufio
           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
+            normalize_zig_entries(scanner.wait(timeout: 60))
           ensure
             scanner.close
           end
@@ -324,28 +383,19 @@ module Rufio
           original.merge(zig: NativeScannerZigFFI.available?)
         end
 
-        # autoモードの優先順位を更新（zig > ruby）
-        def mode=(value)
-          case value
-          when 'auto'
-            # 優先順位: Zig > Ruby
-            if NativeScannerZigFFI.available?
-              @mode = 'zig'
-              @current_library = nil
-            else
-              @mode = 'ruby'
-              @current_library = nil
-            end
-          when 'zig'
-            if NativeScannerZigFFI.available?
-              @mode = 'zig'
-              @current_library = nil
-            else
-              @mode = 'ruby'
-              @current_library = nil
-            end
-          else
-            send(:original_mode=, value)
+        private
+
+        def normalize_zig_entries(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]
+            }
           end
         end
       end

data/lib/rufio/native_zip.rb

@@ -0,0 +1,121 @@
+# frozen_string_literal: true
+
+require 'fiddle'
+require_relative 'native_scanner'
+require_relative 'native_scanner_zig'
+
+module Rufio
+  # Zig 実装の ZIP データ処理（並列・GVL 外）。
+  #
+  # 安全性の検証・パスの決定・ディレクトリ作成・rename・権限と日時の設定は Ruby 側
+  # （ZipExtractor / ZipWriter）が担い、ここではエントリ単位のデータ処理だけを行う。
+  # - 展開: ZIP 内の指定範囲を読み、伸長し、宣言サイズと CRC-32 を検証して一時ファイルに書く
+  # - 圧縮: ファイルを raw DEFLATE で一時ファイルに書き、CRC-32 とサイズを返す
+  module NativeZip
+    STATE_RUNNING = 1
+    STATE_DONE = 2
+    STATE_CANCELLED = 3
+    POLL_INTERVAL = 0.005
+
+    # タスクごとの結果コード（Zig 側 zip.zig の Status と一致させる）
+    STATUS_OK = 0
+    STATUS_CRC_MISMATCH = 1
+    STATUS_SIZE_MISMATCH = 2
+    STATUS_CORRUPT = 3
+    STATUS_IO_ERROR = 4
+    STATUS_CANCELLED = 5
+    STATUS_TOO_LARGE = 6
+    STATUS_PENDING = 255
+
+    class << self
+      def available?
+        return false if ENV['RUFIO_NATIVE_ZIP'] == '0'
+
+        NativeScannerZigFFI.zip_available?
+      end
+    end
+
+    # 実行中のジョブ（展開・圧縮共通）
+    class Job
+      def initialize(handle, count)
+        raise StandardError, 'Failed to start native ZIP job' if handle.zero?
+
+        @handle = handle
+        @count = count
+        @done = Fiddle::Pointer.malloc(8, Fiddle::RUBY_FREE)
+        @total = Fiddle::Pointer.malloc(8, Fiddle::RUBY_FREE)
+      end
+
+      # 完了まで待つ。progress には (処理済みバイト数, 合計バイト数) を渡す。
+      # cancelled が true を返したらキャンセルを要求し、終了を待ってから戻る
+      def wait(progress: nil, cancelled: nil)
+        loop do
+          state = NativeScannerZigFFI.core_zip_state(@handle)
+          report(progress)
+          return state unless state == STATE_RUNNING
+
+          NativeScannerZigFFI.core_zip_cancel(@handle) if cancelled&.call
+          sleep POLL_INTERVAL
+        end
+      end
+
+      def status(index)
+        NativeScannerZigFFI.core_zip_status(@handle, index)
+      end
+
+      def close
+        return if @handle.zero?
+
+        NativeScannerZigFFI.core_zip_destroy(@handle)
+        @handle = 0
+      end
+
+      protected
+
+      attr_reader :handle
+
+      private
+
+      def report(progress)
+        return unless progress
+
+        NativeScannerZigFFI.core_zip_progress(@handle, @done, @total)
+        progress.call(@done[0, 8].unpack1('Q<'), @total[0, 8].unpack1('Q<'))
+      end
+    end
+
+    # @param zip_path [String]
+    # @param tasks [Array<Hash>] data_offset:, compressed_size:, size:, crc32:, method:, output: (一時ファイルのパス)
+    def self.extract(zip_path, tasks, threads: 0)
+      buffer = tasks.map do |task|
+        output = task[:output].b
+        [task[:data_offset], task[:compressed_size], task[:size], task[:crc32], task[:method], output.bytesize]
+          .pack('Q<Q<Q<L<CL<') + output
+      end.join
+      path = zip_path.b
+      Job.new(NativeScannerZigFFI.core_zip_extract_create(path, path.bytesize, buffer, buffer.bytesize, threads), tasks.length)
+    end
+
+    # 圧縮ジョブ
+    class DeflateJob < Job
+      # @return [Array(Integer, Integer, Integer, Integer)] status, crc32, 圧縮後サイズ, 元サイズ
+      def result(index)
+        crc = Fiddle::Pointer.malloc(4, Fiddle::RUBY_FREE)
+        compressed = Fiddle::Pointer.malloc(8, Fiddle::RUBY_FREE)
+        size = Fiddle::Pointer.malloc(8, Fiddle::RUBY_FREE)
+        status = NativeScannerZigFFI.core_zip_deflate_result(handle, index, crc, compressed, size)
+        [status, crc[0, 4].unpack1('L<'), compressed[0, 8].unpack1('Q<'), size[0, 8].unpack1('Q<')]
+      end
+    end
+
+    # @param tasks [Array<Hash>] source:, output: (一時ファイルのパス)
+    def self.deflate(tasks, level:, threads: 0)
+      buffer = tasks.map do |task|
+        source = task[:source].b
+        output = task[:output].b
+        [source.bytesize].pack('L<') + source + [output.bytesize].pack('L<') + output
+      end.join
+      DeflateJob.new(NativeScannerZigFFI.core_zip_deflate_create(buffer, buffer.bytesize, level, threads), tasks.length)
+    end
+  end
+end

data/lib/rufio/navigation_controller.rb

@@ -67,31 +67,18 @@ module Rufio
     # @param in_help_mode [Boolean] ヘルプモード中かどうか
     # @param in_log_viewer_mode [Boolean] ログビューワモード中かどうか
     def navigate_enter(entry, in_help_mode, in_log_viewer_mode)
-      return false unless entry
-
-      if entry[:type] == 'directory'
-        return false if in_help_mode || in_log_viewer_mode
+      return false unless entry && entry[:type] == 'directory'
+      return false if in_help_mode || in_log_viewer_mode
 
-        result = @directory_listing.navigate_to(entry[:name])
-        if result
-          @current_index = 0
-          clear_filter_mode
-        end
-        result
-      else
-        false
-      end
+      perform_navigation { @directory_listing.navigate_to(entry[:name]) }
     end
 
     def navigate_parent
-      return false unless @directory_listing
+      perform_navigation { @directory_listing.navigate_to_parent }
+    end
 
-      result = @directory_listing.navigate_to_parent
-      if result
-        @current_index = 0
-        clear_filter_mode
-      end
-      result
+    def navigate_to_directory(path)
+      perform_navigation { @directory_listing.navigate_to_path(path) }
     end
 
     def refresh
@@ -262,5 +249,16 @@ module Rufio
         navigate_enter(entry, in_help_mode, in_log_viewer_mode)
       end
     end
+
+    private
+
+    # 移動に成功したときだけ、移動後の選択・フィルタ状態を更新する。
+    def perform_navigation
+      return false unless @directory_listing
+
+      result = yield
+      clear_filter_mode if result
+      result
+    end
   end
 end

data/lib/rufio/screen.rb

@@ -229,12 +229,7 @@ module Rufio
       return if out_of_bounds?(x, y)
 
       char_width = width || TextUtils.display_width(char)
-      @overlay_cells[y][x] = {
-        char: char,
-        fg: fg,
-        bg: bg,
-        width: char_width
-      }
+      @overlay_cells[y][x] = Cell.new(char, fg, bg, char_width)
 
       @dirty_rows.add(y)
 
@@ -243,12 +238,7 @@ module Rufio
         (char_width - 1).times do |offset|
           next_x = x + 1 + offset
           break if next_x >= @width
-          @overlay_cells[y][next_x] = {
-            char: '',
-            fg: nil,
-            bg: nil,
-            width: 0
-          }
+          @overlay_cells[y][next_x] = Cell.new('', nil, nil, 0)
         end
       end
     end

data/lib/rufio/script_executor.rb

@@ -83,11 +83,7 @@ module Rufio
         options[:chdir] = chdir if chdir
         spawn_env = env || {}
 
-        if timeout
-          execute_shell_with_timeout(dsl_command.shell_command, spawn_env, options, timeout)
-        else
-          execute_shell_without_timeout(dsl_command.shell_command, spawn_env, options)
-        end
+        execute_with_options([dsl_command.shell_command], spawn_env, options, timeout)
       rescue StandardError => e
         build_error_result(e)
       end
@@ -133,8 +129,11 @@ module Rufio
           # プロセスを終了
           if pid
             begin
-              Process.kill("TERM", pid)
-              sleep 0.1
+              # Windows は TERM を送れない（Errno::EINVAL）ため KILL だけで終了させる
+              unless Gem.win_platform?
+                Process.kill("TERM", pid)
+                sleep 0.1
+              end
               Process.kill("KILL", pid)
             rescue Errno::ESRCH, Errno::EPERM
               # プロセスが既に終了している、または権限がない
@@ -176,72 +175,6 @@ module Rufio
         }
       end
 
-      # シェルコマンドをタイムアウト付きで実行
-      def execute_shell_with_timeout(shell_command, env, options, timeout_sec)
-        stdout = ""
-        stderr = ""
-        status = nil
-        timed_out = false
-        pid = nil
-
-        begin
-          Timeout.timeout(timeout_sec) do
-            args = env.empty? ? [shell_command] : [env, shell_command]
-            stdin, stdout_io, stderr_io, wait_thread = Open3.popen3(*args, **options)
-            pid = wait_thread.pid
-            stdin.close
-            stdout = stdout_io.read
-            stderr = stderr_io.read
-            stdout_io.close
-            stderr_io.close
-            status = wait_thread.value
-          end
-        rescue Timeout::Error
-          timed_out = true
-          if pid
-            begin
-              Process.kill("TERM", pid)
-              sleep 0.1
-              Process.kill("KILL", pid)
-            rescue Errno::ESRCH, Errno::EPERM
-              # プロセスが既に終了している、または権限がない
-            end
-          end
-        end
-
-        if timed_out
-          {
-            success: false,
-            exit_code: nil,
-            stdout: stdout,
-            stderr: stderr,
-            timeout: true
-          }
-        else
-          {
-            success: status&.success? || false,
-            exit_code: status&.exitstatus || 1,
-            stdout: stdout,
-            stderr: stderr,
-            timeout: false
-          }
-        end
-      end
-
-      # シェルコマンドをタイムアウトなしで実行
-      def execute_shell_without_timeout(shell_command, env, options)
-        args = env.empty? ? [shell_command] : [env, shell_command]
-        stdout, stderr, status = Open3.capture3(*args, **options)
-
-        {
-          success: status.success?,
-          exit_code: status.exitstatus,
-          stdout: stdout,
-          stderr: stderr,
-          timeout: false
-        }
-      end
-
       # エラー結果を構築
       def build_error_result(error)
         {