rufio 1.0.4 → 1.3.0

data/lib/rufio/global_search.rb

@@ -0,0 +1,373 @@
+# frozen_string_literal: true
+
+require 'thread'
+require_relative 'text_utils'
+require_relative 'config_loader'
+require_relative 'document_text_extractor'
+require_relative 'native_content_search'
+
+module Rufio
+  # ブックマーク配下のファイル名・テキスト内容をバックグラウンドで横断検索する。
+  class GlobalSearch
+    SPINNER_FRAMES = ['|', '/', '-', '\\'].freeze
+    SPINNER_INTERVAL = 0.12
+    # 検索語に一致した部分の表示（黒の太字・黄色背景）
+    MATCH_FG = "\e[30m\e[1m"
+    MATCH_BG = "\e[43m"
+
+    attr_reader :query, :results, :errors, :selected_index, :search_type, :skipped_files
+
+    class << self
+      # nil: 利用可能なら Zig 実装を使う（RUFIO_NATIVE_SEARCH=0 で無効化）
+      attr_writer :native_search
+
+      def native_search?
+        enabled = @native_search.nil? ? ENV['RUFIO_NATIVE_SEARCH'] != '0' : @native_search
+        enabled && NativeContentSearch.available?
+      end
+    end
+
+    def initialize
+      @active = false
+      @scanning = false
+      @worker = nil
+      @document_extractor = DocumentTextExtractor.new
+      @document_cache = DocumentTextCache.new(extractor: @document_extractor)
+    end
+
+    def active?
+      @active
+    end
+
+    def scanning?
+      @scanning
+    end
+
+    def open(bookmarks)
+      close
+      @active = true
+      @query = ''
+      @search_type = :filename
+      @excluded_extensions = ConfigLoader.global_search_excluded_extensions
+      @bookmark_count = bookmarks.length
+      @roots = bookmarks.map { |bookmark| [bookmark[:name].to_s, bookmark[:path].to_s] }
+      start_scan
+      true
+    end
+
+    def close
+      @active = false
+      @scanning = false
+      @worker&.kill
+      @worker&.join
+      @worker = nil
+    end
+
+    # 1フレーム当たりの処理量を制限し、検索中も入力を受け付ける。
+    def poll
+      return false unless active?
+
+      changed = false
+      256.times do
+        event = begin
+          @events.pop(true)
+        rescue ThreadError
+          break
+        end
+        changed = true
+        type, value = event
+        case type
+        when :entry
+          @entries << value
+          @results << value if @search_type == :content || matches_query?(value)
+        when :entries
+          # Zig 実装の結果はまとめて届くので、1 フレーム 256 件の上限に縛られない
+          @entries.concat(value)
+          @results.concat(value)
+        when :error then @errors << value
+        when :skipped then @skipped_files += value || 1
+        when :done then @scanning = false
+        end
+      end
+      if scanning?
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        if now - @last_spinner_update >= SPINNER_INTERVAL
+          @spinner_index = (@spinner_index + 1) % SPINNER_FRAMES.length
+          @last_spinner_update = now
+          changed = true
+        end
+      end
+      changed
+    end
+
+    def handle_key(key)
+      case key
+      when "\e" then close
+      when "\t"
+        @search_type = @search_type == :filename ? :content : :filename
+        start_scan
+      when "\r", "\n" then return @results[@selected_index]
+      when :down then @selected_index = [@selected_index + 1, [@results.length - 1, 0].max].min
+      when :up then @selected_index = [@selected_index - 1, 0].max
+      when "\x0e" then handle_key(:down) # Ctrl+N
+      when "\x10" then handle_key(:up)   # Ctrl+P
+      when "\x15" then update_query('')  # Ctrl+U
+      when "\u007f", "\b" then update_query(@query[0...-1])
+      else
+        update_query(@query + key) if key.is_a?(String) && !key.empty? && key.each_codepoint.all? { |c| c >= 32 && c != 127 }
+      end
+      nil
+    end
+
+    def draw(screen)
+      screen.clear
+      width = screen.width
+      type = @search_type == :content ? 'Content' : 'File names'
+      write_line(screen, 0, "G mode - #{type} | Tab: Switch name/content search", width, "\e[1;36m")
+      write_line(screen, 1, "Search: #{@query}_", width)
+      state = if scanning?
+                "[#{SPINNER_FRAMES[@spinner_index]}] Searching..."
+              elsif @search_type == :content && @query.empty?
+                'Ready'
+              else
+                'Search complete'
+              end
+      color = scanning? ? "\e[1;33m" : "\e[32m"
+      write_line(screen, 2, "#{state} | #{@bookmark_count} bookmarks | #{@results.length} matches | #{@errors.length} errors | #{@skipped_files} skipped", width, color)
+      row_height = @search_type == :content ? 2 : 1
+      capacity = [screen.height - 6, 0].max / row_height
+      first = [@selected_index - capacity + 1, 0].max
+      @results.slice(first, capacity).to_a.each_with_index do |entry, index|
+        selected = first + index == @selected_index
+        prefix = "#{selected ? '>' : ' '} [#{entry[:bookmark]}] "
+        text = "#{prefix}#{entry[:relative_path]}"
+        text += if entry[:location]
+                  " - #{entry[:location]}"
+                elsif entry[:line_number]
+                  ":#{entry[:line_number]}"
+                else
+                  ''
+                end
+        y = index * row_height + 3
+        # ファイル名検索はパス、本文検索はスニペットの一致箇所をハイライトする
+        path_highlight = @search_type == :filename ? prefix.length : nil
+        write_line(screen, y, text, width, selected ? "\e[1;36m" : nil, highlight_from: path_highlight)
+        write_line(screen, y + 1, "    #{entry[:match_text]}", width, highlight_from: 4) if entry[:match_text]
+      end
+      if @results.empty?
+        message = if @bookmark_count.zero?
+                    'No bookmarks. Add directories with b in Files mode.'
+                  elsif scanning?
+                    'Searching bookmarked directories...'
+                  elsif @search_type == :content && @query.empty?
+                    'Type a string to search inside text files.'
+                  elsif !@errors.empty? && @entries.empty?
+                    'No readable files in bookmarked directories.'
+                  else
+                    'No matching files. Edit your search to try again.'
+                  end
+        write_line(screen, 3, message, width)
+      end
+      write_line(screen, screen.height - 3, @results[@selected_index]&.[](:path) || @errors.first.to_s, width, "\e[90m")
+      write_line(screen, screen.height - 2, 'ESC: Back | Enter: Go to file | Up/Down: Select | Type: Search', width)
+    end
+
+    private
+
+    def start_scan
+      @worker&.kill
+      @worker&.join
+      @worker = nil
+      @entries = []
+      @results = []
+      @errors = []
+      @skipped_files = 0
+      @selected_index = 0
+      @events = SizedQueue.new(256)
+      @spinner_index = 0
+      @last_spinner_update = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+      @scanning = !(@search_type == :content && @query.empty?)
+      return unless @scanning
+
+      roots, events, type, query = @roots, @events, @search_type, @query.downcase
+      native_cache = self.class.native_search? ? (@native_cache ||= NativeContentSearch::Cache.new) : nil
+      @worker = Thread.new do
+        begin
+          if native_cache && type == :content && NativeContentSearch.supports_query?(query)
+            scan_roots_natively(roots, events, query, native_cache)
+          else
+            scan_roots(roots, events, type, query)
+          end
+        rescue StandardError => e
+          events << [:error, e.message]
+        end
+        events << [:done, nil]
+      end
+    end
+
+    def update_query(query)
+      @query = query
+      @selected_index = 0
+      @search_type == :content ? start_scan : filter_results
+    end
+
+    def filter_results
+      query = @query.downcase
+      @results = @entries.select { |entry| entry[:relative_path].scrub.downcase.include?(query) }
+      @selected_index = [[@selected_index, @results.length - 1].min, 0].max
+    end
+
+    def matches_query?(entry)
+      entry[:relative_path].scrub.downcase.include?(@query.downcase)
+    end
+
+    def scan_roots(roots, events, type, query)
+      visited_dirs = {}
+      roots.each do |name, root|
+        begin
+          root = File.expand_path(root)
+          raise Errno::ENOTDIR, root unless File.directory?(root)
+
+          pending = [root]
+          until pending.empty?
+            directory = pending.pop
+            canonical = File.realpath(directory)
+            next if visited_dirs[canonical]
+
+            visited_dirs[canonical] = true
+            begin
+              Dir.each_child(directory) do |child|
+                path = File.join(directory, child)
+                # ディレクトリシンボリックリンクは追わず、循環・範囲外の走査を防ぐ。
+                if File.directory?(path)
+                  pending << path unless File.symlink?(path)
+                elsif File.file?(path)
+                  if child.scrub.downcase.end_with?(*@excluded_extensions)
+                    events << [:skipped, nil]
+                    next
+                  end
+
+                  entry = { path: path, bookmark: name, relative_path: path.delete_prefix(root + File::SEPARATOR) }
+                  if type == :content
+                    scan_content(entry, query, events)
+                  else
+                    events << [:entry, entry]
+                  end
+                end
+              end
+            rescue SystemCallError, IOError => e
+              events << [:error, "#{directory}: #{e.message}"]
+            end
+          end
+        rescue SystemCallError, IOError => e
+          events << [:error, "#{name}: #{e.message}"]
+        end
+      end
+    end
+
+    # Zig 実装で走査・検索し、PDF などのドキュメントだけ Ruby 側で抽出する
+    def scan_roots_natively(roots, events, query, cache)
+      valid_roots = []
+      roots.each do |name, root|
+        root = File.expand_path(root)
+        raise Errno::ENOTDIR, root unless File.directory?(root)
+
+        valid_roots << [name, root]
+      rescue SystemCallError, IOError => e
+        events << [:error, "#{name}: #{e.message}"]
+      end
+      return if valid_roots.empty?
+
+      engine = NativeContentSearch.new(roots: valid_roots.map(&:last), query: query,
+                                       excluded_extensions: @excluded_extensions,
+                                       document_extensions: DocumentTextExtractor::EXTENSIONS, cache: cache)
+      engine.each_batch do |batch|
+        entries = []
+        batch.each do |kind, *args|
+          case kind
+          when :match, :document
+            name, root = valid_roots[args[0]]
+            path = args[1]
+            entry = { path: path, bookmark: name, relative_path: path.delete_prefix(root + File::SEPARATOR) }
+            if kind == :document
+              scan_content(entry, query, events)
+            else
+              entries << entry.merge(line_number: args[2], match_text: args[3])
+            end
+          when :error then events << [:error, args[1]]
+          when :skipped then events << [:skipped, args[0]]
+          end
+        end
+        events << [:entries, entries] unless entries.empty?
+      end
+    ensure
+      engine&.close
+    end
+
+    def scan_content(entry, query, events)
+      if @document_extractor.supported?(entry[:path])
+        @document_cache.each_record(entry[:path]) do |record|
+          match_index = record[:search_text].index(query)
+          next unless match_index
+
+          snippet = record[:text][[match_index - 30, 0].max, 200].to_s.strip
+          metadata = record.reject { |key, _| key == :text || key == :search_text }
+          events << [:entry, entry.merge(metadata).merge(match_text: snippet)]
+        end
+        return
+      end
+
+      File.open(entry[:path], 'rb') do |file|
+        sample = file.read(8192).to_s
+        if sample.include?("\0")
+          events << [:skipped, nil]
+          return
+        end
+
+        file.rewind
+        file.each_line.with_index(1) do |raw_line, number|
+          line = raw_line.force_encoding(Encoding::UTF_8).scrub
+          match_index = line.downcase.index(query)
+          next unless match_index
+
+          snippet_start = [match_index - 30, 0].max
+          snippet = line[snippet_start, 200].strip
+          events << [:entry, entry.merge(line_number: number, match_text: snippet)]
+        end
+      end
+    rescue SystemCallError, IOError, DocumentTextExtractor::ExtractionError => e
+      events << [:error, "#{entry[:path]}: #{e.message}"]
+    end
+
+    def write_line(screen, y, text, width, color = nil, highlight_from: nil)
+      safe_text = text.scrub.gsub(/[[:cntrl:]]/, ' ')
+      visible = TextUtils.truncate_to_width(safe_text, width)
+      screen.put_string(0, y, visible, fg: color)
+      return unless highlight_from
+
+      match_ranges(visible, highlight_from).each do |start, length|
+        x = TextUtils.display_width(visible[0, start])
+        screen.put_string(x, y, visible[start, length], fg: MATCH_FG, bg: MATCH_BG)
+      end
+    end
+
+    # 検索と同じく大文字小文字を区別せず、from 文字目以降の一致位置を [開始, 長さ] で返す
+    def match_ranges(text, from)
+      needle = @query.to_s.downcase.chars
+      return [] if needle.empty?
+
+      folded = text.chars.map(&:downcase)
+      ranges = []
+      index = from
+      while index + needle.length <= folded.length
+        if folded[index, needle.length] == needle
+          ranges << [index, needle.length]
+          index += needle.length
+        else
+          index += 1
+        end
+      end
+      ranges
+    end
+  end
+end

data/lib/rufio/help_menu.rb

@@ -62,21 +62,46 @@ module Rufio
           '', 'Selection and file operations',
           "#{key(:select)}: Select / unselect file",
           "#{key(:copy_selected)}/#{key(:move_selected)}/#{key(:delete_selected)}: Copy / move / delete selected files",
+          "#{key(:zoxide)}: Extract selected .zip files / compress selected items",
           "#{key(:rename)}/#{key(:delete)}: Rename / delete current file",
           "#{key(:create_file)}/#{key(:create_dir)}: Create file / directory",
           '', 'Search and bookmarks',
           "#{key(:filter)}: Filter | Enter: Apply | ESC: Clear",
           "#{key(:fzf_search)}: Filename search (fzf)",
           "#{key(:rga_search)}: Content search (rga)",
+          "#{key(:global_search)}: Search file names or contents across all bookmarks",
           "#{key(:add_bookmark)}/#{key(:bookmark_menu)}: Add / manage bookmarks",
           'Tab / Shift+Tab: Next / previous bookmark',
           "1-9: Jump to bookmark | #{key(:start_dir)}: Start directory",
-          "#{key(:zoxide)}: Directory history (zoxide)",
-          "#{key(:quit)}: Quit (with confirmation)"
+          "#{key(:zoxide)}: Directory history (zoxide, when nothing is selected)",
+          "#{key(:quit)}: Quit (with confirmation)",
+          "#{key(:quit_cd)}: Quit and cd to the current directory (rufio --shell-init)"
         ]
       when 'Modes'
         [
           'Files', 'Browse directories, select files and view previews.',
+          '', "[#{key(:config_mode)}] Config",
+          'Open ~/.config/rufio/ to edit settings and scripts.',
+          'The config directory is created if it does not exist.',
+          'Navigation, previews and file operations work as in Files.',
+          "#{key(:navigate_parent)}: Parent directory; leaving config returns to Files.",
+          '', "[#{key(:global_search)}] Global search",
+          'Search file names or text inside every bookmarked directory.',
+          'Tab: Switch File names / Content (literal, case insensitive)',
+          'Content results show file, line number and matching text.',
+          'Documents: .pdf (page), .xlsx (sheet/cell), .pptx (slide)',
+          'Ruby extracts document text; no Python or Office is needed.',
+          'Unchanged document text is cached in memory for faster searches.',
+          'Images need OCR; legacy .xls/.ppt and slide notes are unsupported.',
+          'Yellow Searching... + spinner: Search is running.',
+          'Green Search complete: All bookmarked directories scanned.',
+          'Exclude extensions in ~/.config/rufio/config.rb:',
+          'GLOBAL_SEARCH_EXCLUDED_EXTENSIONS = %w[.zip .log]',
+          'Applies to names and contents. Restart Rufio after editing.',
+          'Extensions ignore case; leading dots are optional; [] excludes none.',
+          'Type to filter | Up/Down or Ctrl+N/P: Select',
+          'Enter: Go to the selected file in Files mode',
+          'ESC: Return to the previous mode | Ctrl+U: Clear query',
           '', "[#{key(:log_viewer)}] Logs",
           'Browse command logs. Enter opens a preview.',
           'ESC: Leave preview; ESC again: Return to Files.',

data/lib/rufio/interpreter_resolver.rb

@@ -1,20 +1,15 @@
 # frozen_string_literal: true
 
+require_relative 'script_file'
+
 module Rufio
   # 拡張子からインタープリタを解決するクラス
   class InterpreterResolver
     # デフォルトの拡張子とインタープリタのマッピング
-    DEFAULT_EXTENSIONS = {
-      ".rb" => "ruby",
-      ".py" => "python3",
-      ".sh" => "bash",
-      ".js" => "node",
-      ".pl" => "perl",
-      ".lua" => "lua",
-      ".ts" => "ts-node",
-      ".php" => "php",
-      ".ps1" => nil # プラットフォーム依存
-    }.freeze
+    # DSLでは .sh にインタープリタを指定し、WindowsのPowerShellを別途解決する。
+    DEFAULT_EXTENSIONS = ScriptFile::INTERPRETERS.merge(
+      ".sh" => "bash", ".lua" => "lua", ".php" => "php", ".ps1" => nil
+    ).freeze
 
     class << self
       # 拡張子からインタープリタを解決する

data/lib/rufio/job_manager.rb

@@ -23,12 +23,9 @@ module Rufio
       job = TaskStatus.new(
         id: @next_id,
         name: name,
-        path: path
+        path: path,
+        command: command
       )
-      # commandを保存（TaskStatusに追加）
-      job.instance_variable_set(:@command, command)
-      job.define_singleton_method(:command) { @command }
-
       @jobs << job
       @next_id += 1
       job

data/lib/rufio/key_input.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'io/console'
+
+module Rufio
+  # ダイアログなどのブロッキングなキー入力の読み取り口。
+  # Windows ではメインループ用の入力スレッドが常に STDIN.getch で待機しているため、
+  # ダイアログが STDIN.getch を直接呼ぶと 1 キーずつ入力を奪い合い、2 回押さないと入力できない。
+  # 入力キューが接続されている間はキューから読み、それ以外は STDIN.getch を使う。
+  module KeyInput
+    # Ruby 3.2+ は Queue#pop(timeout:) で正確に待機する（sleep ポーリングは
+    # Windows のタイマー分解能 約15ms により遅延する）。それ以前はポーリング。
+    QUEUE_POP_TIMEOUT_SUPPORTED = Queue.instance_method(:pop).parameters.any? { |_, n| n == :timeout }
+    MULTIBYTE_TIMEOUT = 0.005
+
+    class << self
+      attr_reader :queue
+
+      def attach(queue)
+        @queue = queue
+      end
+
+      def detach
+        @queue = nil
+      end
+
+      # 1 文字（マルチバイト対応）を読むまでブロックする
+      def getch
+        queue = @queue
+        return STDIN.getch unless queue
+
+        loop do
+          char = build_char(queue.pop, queue)
+          return char if char
+        end
+      end
+
+      # キューからタイムアウト付きで Integer バイトを取り出す
+      def pop_with_timeout(queue, timeout_sec)
+        return queue.pop(timeout: timeout_sec) if QUEUE_POP_TIMEOUT_SUPPORTED
+
+        deadline = Time.now + timeout_sec
+        loop do
+          begin
+            return queue.pop(true)
+          rescue ThreadError
+            return nil if Time.now >= deadline
+
+            sleep 0.001
+          end
+        end
+      end
+
+      # first_byte_int に続く UTF-8 の後続バイトをキューから読み、1 文字に組み立てる
+      def build_char(first_byte_int, queue)
+        remaining = case first_byte_int
+                    when 0x00..0x7F then 0
+                    when 0xC0..0xDF then 1
+                    when 0xE0..0xEF then 2
+                    when 0xF0..0xF7 then 3
+                    else 0
+                    end
+        return first_byte_int.chr(Encoding::UTF_8) if remaining == 0
+
+        buf = first_byte_int.chr(Encoding::BINARY)
+        remaining.times do
+          b = pop_with_timeout(queue, MULTIBYTE_TIMEOUT)
+          return nil if b.nil?
+
+          buf << b.chr(Encoding::BINARY)
+        end
+        result = buf.force_encoding(Encoding::UTF_8)
+        result.valid_encoding? ? result : nil
+      end
+    end
+  end
+end