rufio 1.1.0 → 1.3.0

data/lib/rufio/native_content_search.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+require 'fiddle'
+require_relative 'native_scanner'
+require_relative 'native_scanner_zig'
+
+module Rufio
+  # Zig 実装のコンテンツ検索（G mode 用）。
+  # Ruby 実装（GlobalSearch#scan_content）と同じ結果を、並列走査と SIMD 検索で返す。
+  class NativeContentSearch
+    HEADER_SIZE = 25
+    HEADER_FORMAT = 'CL<Q<L<L<L<'
+    STATE_SCANNING = 1
+    KINDS = { 1 => :match, 2 => :document, 3 => :error }.freeze
+    MAX_QUERY_BYTES = 1024
+    POLL_INTERVAL = 0.001
+
+    # 検索をまたいでファイル内容を保持するキャッシュ（mtime/inode/サイズで毎回検証する）
+    class Cache
+      DEFAULT_MAX_BYTES = 256 * 1024 * 1024
+
+      attr_reader :handle
+
+      def self.finalizer(handle)
+        proc { NativeScannerZigFFI.core_cache_destroy(handle) }
+      end
+
+      def initialize(max_bytes: DEFAULT_MAX_BYTES)
+        @handle = NativeScannerZigFFI.core_cache_create(max_bytes)
+        raise StandardError, 'Failed to create search cache' if @handle.zero?
+
+        ObjectSpace.define_finalizer(self, self.class.finalizer(@handle))
+      end
+
+      def cached_bytes
+        @handle.zero? ? 0 : NativeScannerZigFFI.core_cache_bytes(@handle)
+      end
+
+      # このキャッシュを使う検索をすべて close してから呼ぶこと
+      def close
+        return if @handle.zero?
+
+        ObjectSpace.undefine_finalizer(self)
+        NativeScannerZigFFI.core_cache_destroy(@handle)
+        @handle = 0
+      end
+    end
+
+    def self.available?
+      NativeScannerZigFFI.search_available?
+    end
+
+    # Zig 側は ASCII のみ大文字小文字を畳み込むため、大文字小文字を持つ非 ASCII 文字は Ruby 実装に任せる
+    def self.supports_query?(query)
+      return false if query.empty? || query.bytesize > MAX_QUERY_BYTES
+
+      query.each_char.all? { |char| char.ascii_only? || (char.upcase == char && char.downcase == char) }
+    end
+
+    # マッチ周辺のバイト列から Ruby 実装と同じスニペット（30 文字前から 200 文字）を作る
+    def self.snippet(window, offset)
+      line = window.dup.force_encoding(Encoding::UTF_8).scrub
+      match_index = window.byteslice(0, offset).force_encoding(Encoding::UTF_8).scrub.length
+      line[[match_index - 30, 0].max, 200].to_s.strip
+    end
+
+    def initialize(roots:, query:, excluded_extensions: [], document_extensions: [], cache: nil, threads: 0)
+      raise StandardError, 'Zig content search is not available' unless self.class.available?
+
+      @cache = cache
+      @path_encoding = Encoding.find('filesystem')
+      roots_buf = pack(roots)
+      query_buf = query.b
+      excluded_buf = pack(excluded_extensions)
+      documents_buf = pack(document_extensions)
+      @handle = NativeScannerZigFFI.core_search_create(
+        roots_buf, roots_buf.bytesize, query_buf, query_buf.bytesize,
+        excluded_buf, excluded_buf.bytesize, documents_buf, documents_buf.bytesize,
+        threads, cache ? cache.handle : 0
+      )
+      raise StandardError, 'Failed to start native search' if @handle.zero?
+
+      @length = Fiddle::Pointer.malloc(8, Fiddle::RUBY_FREE)
+      @skipped = 0
+    end
+
+    # [:match, root_index, path, line_number, snippet] / [:document, root_index, path] /
+    # [:error, root_index, message] / [:skipped, count] を検索終了まで順に返す
+    def each_event(&block)
+      return enum_for(:each_event) unless block_given?
+
+      each_batch { |batch| batch.each(&block) }
+    end
+
+    # 1 回の取り出しごとにイベント配列を返す（UI へまとめて渡すため）
+    def each_batch
+      return enum_for(:each_batch) unless block_given?
+
+      loop do
+        state = NativeScannerZigFFI.core_search_state(@handle)
+        data = drain
+        batch = []
+        each_record(data) { |event| batch << event }
+        skipped = NativeScannerZigFFI.core_search_skipped(@handle)
+        if skipped > @skipped
+          batch << [:skipped, skipped - @skipped]
+          @skipped = skipped
+        end
+        yield batch unless batch.empty?
+        break if data.empty? && state != STATE_SCANNING
+
+        sleep POLL_INTERVAL if data.empty?
+      end
+    end
+
+    def close
+      return if @handle.nil? || @handle.zero?
+
+      NativeScannerZigFFI.core_search_destroy(@handle)
+      @handle = 0
+    end
+
+    private
+
+    def pack(values)
+      values.map { |value| value.to_s.b }.join("\0")
+    end
+
+    def drain
+      pointer = NativeScannerZigFFI.core_search_drain(@handle, @length)
+      length = @length[0, 8].unpack1('Q')
+      length.zero? ? ''.b : pointer.to_str(length)
+    end
+
+    def each_record(data)
+      position = 0
+      while position + HEADER_SIZE <= data.bytesize
+        kind, root, line, offset, path_length, extra_length = data.byteslice(position, HEADER_SIZE).unpack(HEADER_FORMAT)
+        position += HEADER_SIZE
+        path = data.byteslice(position, path_length).force_encoding(@path_encoding)
+        position += path_length
+        extra = data.byteslice(position, extra_length)
+        position += extra_length
+
+        case KINDS[kind]
+        when :match then yield [:match, root, path, line, self.class.snippet(extra, offset)]
+        when :document then yield [:document, root, path]
+        when :error then yield [:error, root, "#{path}: #{extra.force_encoding(Encoding::UTF_8).scrub}"]
+        end
+      end
+    end
+  end
+end

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