rufio 1.1.0 → 1.4.0

data/lib/rufio/config_loader.rb

@@ -51,6 +51,7 @@ module Rufio
           refresh:         'R',
           # ファイル操作
           open_file:       'o',
+          preview:         'P',
           rename:          'r',
           delete:          'd',
           create_file:     'a',
@@ -77,7 +78,8 @@ module Rufio
           help:            '?',
           log_viewer:      'L',
           command_mode:    ':',
-          quit:            'q'
+          quit:            'q',
+          quit_cd:         'T'
         }.freeze
       end
 
@@ -282,17 +284,8 @@ module Rufio
         Config.save_script_paths(SCRIPT_PATHS_YML, paths)
       end
 
-      # YAMLファイルにセクションを保存（Config経由）
-      def save_to_yaml(key, value)
-        Config.save_yaml_config(YAML_CONFIG_PATH, key, value)
-      end
-
       def filter_valid_bookmarks(bookmarks)
-        return [] unless bookmarks.is_a?(Array)
-
-        bookmarks.select do |b|
-          b.is_a?(Hash) && b[:path] && b[:name]
-        end
+        Config.filter_valid_bookmarks(bookmarks)
       end
 
       def load_config_file

data/lib/rufio/dialog_renderer.rb

@@ -19,186 +19,59 @@ module Rufio
     # @option options [String] :border_color Border color ANSI code
     # @option options [String] :title_color Title color ANSI code
     # @option options [String] :content_color Content color ANSI code
+    # @option options [Integer] :scroll_offset First visible content line
+    # @option options [Integer] :total_lines Total scrollable content lines
+    # @option options [Integer] :visible_lines Number of visible scrollable lines
     def draw_floating_window_to_buffer(screen, x, y, width, height, title, content_lines, options = {})
-      # Default options
-      border_color = options[:border_color] || "\e[37m"  # White
-      title_color = options[:title_color] || "\e[1;33m"  # Bold yellow
-      content_color = options[:content_color] || "\e[37m" # White
-
-      # Draw top border
-      screen.put_string(x, y, "┌#{'─' * (width - 2)}┐", fg: border_color)
-
-      # Draw title line if title exists
-      if title
-        title_width = TextUtils.display_width(title)
-        title_padding = (width - 2 - title_width) / 2
-        padded_title = ' ' * title_padding + title
-        title_line = TextUtils.pad_string_to_width(padded_title, width - 2)
-
-        screen.put(x, y + 1, '│', fg: border_color)
-        screen.put_string(x + 1, y + 1, title_line, fg: title_color)
-        screen.put(x + width - 1, y + 1, '│', fg: border_color)
-
-        # Draw title separator
-        screen.put_string(x, y + 2, "├#{'─' * (width - 2)}┤", fg: border_color)
-        content_start_y = y + 3
-      else
-        content_start_y = y + 1
-      end
-
-      # Draw content lines
-      content_height = title ? height - 4 : height - 2
-      content_lines.each_with_index do |line, index|
-        break if index >= content_height
-
-        line_y = content_start_y + index
-        line_content = TextUtils.pad_string_to_width(line, width - 2)
-
-        screen.put(x, line_y, '│', fg: border_color)
-        screen.put_string(x + 1, line_y, line_content, fg: content_color)
-        screen.put(x + width - 1, line_y, '│', fg: border_color)
-      end
-
-      # Fill remaining lines with empty space
-      remaining_lines = content_height - content_lines.length
-      remaining_lines.times do |i|
-        line_y = content_start_y + content_lines.length + i
-        empty_line = ' ' * (width - 2)
-
-        screen.put(x, line_y, '│', fg: border_color)
-        screen.put_string(x + 1, line_y, empty_line)
-        screen.put(x + width - 1, line_y, '│', fg: border_color)
-      end
-
-      # Draw bottom border
-      bottom_y = y + height - 1
-      screen.put_string(x, bottom_y, "└#{'─' * (width - 2)}┘", fg: border_color)
+      draw_window_cells(x, y, width, height, title, content_lines, options,
+                        put_cell: ->(cx, cy, ch, fg: nil) { screen.put(cx, cy, ch, fg: fg) },
+                        put_str: ->(cx, cy, str, fg: nil) { screen.put_string(cx, cy, str, fg: fg) })
     end
 
     # オーバーレイレイヤーにフローティングウィンドウを描画
-    # @param screen [Screen] Screen buffer with overlay enabled
-    # @param x [Integer] X position (column)
-    # @param y [Integer] Y position (row)
-    # @param width [Integer] Window width
-    # @param height [Integer] Window height
-    # @param title [String, nil] Window title (optional)
-    # @param content_lines [Array<String>] Content lines to display
-    # @param options [Hash] Customization options
     def draw_floating_window_to_overlay(screen, x, y, width, height, title, content_lines, options = {})
-      # オーバーレイが有効でない場合は有効化
       screen.enable_overlay unless screen.overlay_enabled?
 
-      border_color = options[:border_color] || "\e[37m"
-      title_color = options[:title_color] || "\e[1;33m"
-      content_color = options[:content_color] || "\e[37m"
-
-      # Draw top border
-      screen.put_overlay_string(x, y, "┌#{'─' * (width - 2)}┐", fg: border_color)
-
-      # Draw title line if title exists
-      if title
-        title_width = TextUtils.display_width(title)
-        title_padding = (width - 2 - title_width) / 2
-        padded_title = ' ' * title_padding + title
-        title_line = TextUtils.pad_string_to_width(padded_title, width - 2)
-
-        screen.put_overlay(x, y + 1, '│', fg: border_color)
-        screen.put_overlay_string(x + 1, y + 1, title_line, fg: title_color)
-        screen.put_overlay(x + width - 1, y + 1, '│', fg: border_color)
-
-        # Draw title separator
-        screen.put_overlay_string(x, y + 2, "├#{'─' * (width - 2)}┤", fg: border_color)
-        content_start_y = y + 3
-      else
-        content_start_y = y + 1
-      end
-
-      # Draw content lines
-      content_height = title ? height - 4 : height - 2
-      content_lines.each_with_index do |line, index|
-        break if index >= content_height
-
-        line_y = content_start_y + index
-        line_content = TextUtils.pad_string_to_width(line, width - 2)
-
-        screen.put_overlay(x, line_y, '│', fg: border_color)
-        screen.put_overlay_string(x + 1, line_y, line_content, fg: content_color)
-        screen.put_overlay(x + width - 1, line_y, '│', fg: border_color)
-      end
-
-      # Fill remaining lines with empty space
-      remaining_lines = content_height - content_lines.length
-      remaining_lines.times do |i|
-        line_y = content_start_y + content_lines.length + i
-        empty_line = ' ' * (width - 2)
-
-        screen.put_overlay(x, line_y, '│', fg: border_color)
-        screen.put_overlay_string(x + 1, line_y, empty_line)
-        screen.put_overlay(x + width - 1, line_y, '│', fg: border_color)
-      end
-
-      # Draw bottom border
-      bottom_y = y + height - 1
-      screen.put_overlay_string(x, bottom_y, "└#{'─' * (width - 2)}┘", fg: border_color)
+      draw_window_cells(x, y, width, height, title, content_lines, options,
+                        put_cell: ->(cx, cy, ch, fg: nil) { screen.put_overlay(cx, cy, ch, fg: fg) },
+                        put_str: ->(cx, cy, str, fg: nil) { screen.put_overlay_string(cx, cy, str, fg: fg) })
     end
 
     # Draw a floating window with title, content, and customizable colors
-    # @param x [Integer] X position (column)
-    # @param y [Integer] Y position (row)
-    # @param width [Integer] Window width
-    # @param height [Integer] Window height
-    # @param title [String, nil] Window title (optional)
-    # @param content_lines [Array<String>] Content lines to display
-    # @param options [Hash] Customization options
-    # @option options [String] :border_color Border color ANSI code
-    # @option options [String] :title_color Title color ANSI code
-    # @option options [String] :content_color Content color ANSI code
     def draw_floating_window(x, y, width, height, title, content_lines, options = {})
-      # Default options
       border_color = options[:border_color] || "\e[37m"  # White
       title_color = options[:title_color] || "\e[1;33m"  # Bold yellow
       content_color = options[:content_color] || "\e[37m" # White
       reset_color = "\e[0m"
+      inner_width = width - 2
 
-      # Draw top border
-      print "\e[#{y};#{x}H#{border_color}┌#{'─' * (width - 2)}┐#{reset_color}"
+      print "\e[#{y};#{x}H#{border_color}┌#{'─' * inner_width}┐#{reset_color}"
 
-      # Draw title line if title exists
       if title
-        title_width = TextUtils.display_width(title)
-        title_padding = (width - 2 - title_width) / 2
-        padded_title = ' ' * title_padding + title
-        title_line = TextUtils.pad_string_to_width(padded_title, width - 2)
+        title_line = format_centered_title(title, inner_width)
         print "\e[#{y + 1};#{x}H#{border_color}│#{title_color}#{title_line}#{border_color}│#{reset_color}"
-
-        # Draw title separator
-        print "\e[#{y + 2};#{x}H#{border_color}├#{'─' * (width - 2)}┤#{reset_color}"
+        print "\e[#{y + 2};#{x}H#{border_color}├#{'─' * inner_width}┤#{reset_color}"
         content_start_y = y + 3
       else
         content_start_y = y + 1
       end
 
-      # Draw content lines
       content_height = title ? height - 4 : height - 2
-      content_lines.each_with_index do |line, index|
-        break if index >= content_height
-
+      content_height.times do |index|
         line_y = content_start_y + index
-        line_content = TextUtils.pad_string_to_width(line, width - 2)
-        print "\e[#{line_y};#{x}H#{border_color}│#{content_color}#{line_content}#{border_color}│#{reset_color}"
-      end
-
-      # Fill remaining lines with empty space
-      remaining_lines = content_height - content_lines.length
-      remaining_lines.times do |i|
-        line_y = content_start_y + content_lines.length + i
-        empty_line = ' ' * (width - 2)
-        print "\e[#{line_y};#{x}H#{border_color}│#{empty_line}│#{reset_color}"
+        if index < content_lines.length
+          line_content = TextUtils.pad_string_to_width(content_lines[index], inner_width)
+          print "\e[#{line_y};#{x}H#{border_color}│#{content_color}#{line_content}#{border_color}│#{reset_color}"
+        else
+          print "\e[#{line_y};#{x}H#{border_color}│#{' ' * inner_width}│#{reset_color}"
+        end
       end
 
-      # Draw bottom border
       bottom_y = y + height - 1
-      print "\e[#{bottom_y};#{x}H#{border_color}└#{'─' * (width - 2)}┘#{reset_color}"
+      print "\e[#{bottom_y};#{x}H#{border_color}└#{'─' * inner_width}┘#{reset_color}"
+      draw_scroll_indicators(x, y, width, height, options) do |cx, cy, label|
+        print "\e[#{cy};#{cx}H#{border_color}#{label}#{reset_color}"
+      end
     end
 
     # Calculate center position for a window
@@ -307,6 +180,71 @@ module Rufio
 
     private
 
+    def format_centered_title(title, inner_width)
+      title_width = TextUtils.display_width(title)
+      title_padding = [(inner_width - title_width) / 2, 0].max
+      padded_title = ' ' * title_padding + title
+      TextUtils.pad_string_to_width(padded_title, inner_width)
+    end
+
+    def draw_window_cells(x, y, width, height, title, content_lines, options, put_cell:, put_str:)
+      border_color = options[:border_color] || "\e[37m"
+      title_color = options[:title_color] || "\e[1;33m"
+      content_color = options[:content_color] || "\e[37m"
+      inner_width = width - 2
+
+      put_str.call(x, y, "┌#{'─' * inner_width}┐", fg: border_color)
+
+      if title
+        title_line = format_centered_title(title, inner_width)
+        put_cell.call(x, y + 1, '│', fg: border_color)
+        put_str.call(x + 1, y + 1, title_line, fg: title_color)
+        put_cell.call(x + width - 1, y + 1, '│', fg: border_color)
+
+        put_str.call(x, y + 2, "├#{'─' * inner_width}┤", fg: border_color)
+        content_start_y = y + 3
+      else
+        content_start_y = y + 1
+      end
+
+      content_height = title ? height - 4 : height - 2
+      empty_line = ' ' * inner_width
+      content_height.times do |index|
+        line_y = content_start_y + index
+        put_cell.call(x, line_y, '│', fg: border_color)
+        if index < content_lines.length
+          line_content = TextUtils.pad_string_to_width(content_lines[index], inner_width)
+          put_str.call(x + 1, line_y, line_content, fg: content_color)
+        else
+          put_str.call(x + 1, line_y, empty_line)
+        end
+        put_cell.call(x + width - 1, line_y, '│', fg: border_color)
+      end
+
+      bottom_y = y + height - 1
+      put_str.call(x, bottom_y, "└#{'─' * inner_width}┘", fg: border_color)
+      draw_scroll_indicators(x, y, width, height, options) do |cx, cy, label|
+        put_str.call(cx, cy, label, fg: border_color)
+      end
+    end
+
+    # 枠内に表示し、本文や操作ガイドの行を消費しない。
+    def draw_scroll_indicators(x, y, width, height, options)
+      total = options[:total_lines]
+      visible = options[:visible_lines]
+      return unless total && visible && total > visible
+      return if width < 3 || height < 2
+
+      offset = [[options.fetch(:scroll_offset, 0), 0].max, total - visible].min
+      [[offset > 0, y, '▲ 上に続く'],
+       [offset + visible < total, y + height - 1, '▼ 下に続く']].each do |shown, row, text|
+        next unless shown
+
+        label = TextUtils.truncate_to_width(text, width - 2)
+        yield x + 1 + (width - 2 - TextUtils.display_width(label)) / 2, row, label
+      end
+    end
+
     # ASCII character range constants
     ASCII_PRINTABLE_START = 32
     ASCII_PRINTABLE_END = 127
@@ -329,7 +267,7 @@ module Rufio
       max_input_width = dialog_width - 8 # Leave space for borders and padding (border 2 + padding 4 + border 2)
 
       loop do
-        char = STDIN.getch
+        char = KeyInput.getch
 
         case char
         when "\e" # Escape - cancel

data/lib/rufio/dialog_support.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'io/console'
+
+module Rufio
+  # ダイアログの表示方式選択と入力待ち・後片付けを共有する。
+  # 利用側は @dialog_renderer と @terminal_ui を設定する。
+  module DialogSupport
+    CONFIRMATION_CANCEL_KEYS = ["n", "\e", "\x03"].freeze
+
+    private
+
+    # 表示とキー判定を共有し、終了確認だけは従来どおり q を無視する。
+    def confirm_dialog(title, content_lines, options = {}, cancel_on_quit: true)
+      confirmed = false
+      show_overlay_dialog(title, content_lines, options) do
+        confirmed = read_confirmation(cancel_on_quit: cancel_on_quit)
+        nil
+      end
+      confirmed
+    end
+
+    def read_confirmation(cancel_on_quit: true)
+      loop do
+        input = KeyInput.getch.downcase
+        return true if input == 'y'
+        return false if CONFIRMATION_CANCEL_KEYS.include?(input) || (cancel_on_quit && input == 'q')
+      end
+    end
+
+    def show_overlay_dialog(title, content_lines, options = {}, &block)
+      use_overlay = @terminal_ui &&
+                    @terminal_ui.respond_to?(:screen) &&
+                    @terminal_ui.respond_to?(:renderer) &&
+                    @terminal_ui.screen &&
+                    @terminal_ui.renderer
+
+      if use_overlay
+        @terminal_ui.show_overlay_dialog(title, content_lines, options, &block)
+      else
+        width = options[:width]
+        height = options[:height]
+
+        unless width && height
+          width, height = @dialog_renderer.calculate_dimensions(content_lines, {
+            title: title,
+            min_width: options[:min_width] || 40,
+            max_width: options[:max_width] || 80
+          })
+        end
+
+        x, y = @dialog_renderer.calculate_center(width, height)
+
+        @dialog_renderer.draw_floating_window(x, y, width, height, title, content_lines, {
+          border_color: options[:border_color] || "\e[37m",
+          title_color: options[:title_color] || "\e[1;33m",
+          content_color: options[:content_color] || "\e[37m"
+        })
+
+        key = block_given? ? yield : KeyInput.getch
+
+        @dialog_renderer.clear_area(x, y, width, height)
+        @terminal_ui&.refresh_display
+
+        key
+      end
+    end
+  end
+end

data/lib/rufio/document_text_extractor.rb

@@ -0,0 +1,167 @@
+# frozen_string_literal: true
+
+require 'pdf/reader'
+require 'csv'
+require 'base64'
+require 'roo'
+require 'zip'
+require 'nokogiri'
+require 'pathname'
+require 'uri'
+
+module Rufio
+  # 文書内の文字列を、元文書の位置情報付きで列挙する。外部コマンドは実行しない。
+  class DocumentTextExtractor
+    class ExtractionError < StandardError; end
+
+    EXTENSIONS = %w[.pdf .xlsx .pptx].freeze
+    DRAWING_NS = 'http://schemas.openxmlformats.org/drawingml/2006/main'
+    PART_URI_PARSER = URI::RFC2396_Parser.new
+
+    def supported?(path)
+      EXTENSIONS.include?(File.extname(path).downcase)
+    end
+
+    def each_record(path)
+      return enum_for(:each_record, path) unless block_given?
+
+      case File.extname(path).downcase
+      when '.pdf' then each_pdf_record(path) { |record| yield record }
+      when '.xlsx' then each_excel_record(path) { |record| yield record }
+      when '.pptx' then each_powerpoint_record(path) { |record| yield record }
+      else raise ExtractionError, "Unsupported document: #{File.extname(path)}"
+      end
+    rescue ExtractionError
+      raise
+    rescue StandardError => e
+      raise ExtractionError, "#{File.basename(path)}: #{e.message}"
+    end
+
+    private
+
+    def each_pdf_record(path)
+      File.open(path, 'rb') do |io|
+        reader = PDF::Reader.new(io)
+        reader.pages.each_with_index do |page, index|
+          page.text.each_line do |text|
+            next if text.strip.empty?
+
+            yield(text: text.chomp, document_type: :pdf, page: index + 1, location: "Page #{index + 1}")
+          end
+        end
+      end
+    end
+
+    def each_excel_record(path)
+      workbook = Roo::Excelx.new(path)
+      workbook.sheets.each do |name|
+        workbook.sheet(name).each_row_streaming do |row|
+          row.compact.each do |cell|
+            value = cell.value
+            next if value.nil? || value.to_s.empty?
+
+            row_number, column = cell.coordinate
+            address = "#{Roo::Utils.number_to_letter(column)}#{row_number}"
+            yield(text: value.to_s, document_type: :xlsx, sheet: name, cell: address, location: "#{name}!#{address}")
+          end
+        end
+      end
+    ensure
+      workbook.close if workbook
+    end
+
+    def read_xml(zip, part)
+      entry = zip.find_entry(part)
+      raise ExtractionError, "Missing document part: #{part}" unless entry
+
+      xml = entry.get_input_stream { |stream| stream.read }
+      Nokogiri::XML(xml) { |config| config.strict.nonet }
+    end
+
+    def each_powerpoint_record(path)
+      Zip::File.open(path) do |zip|
+        presentation = read_xml(zip, 'ppt/presentation.xml')
+        relationships = read_xml(zip, 'ppt/_rels/presentation.xml.rels')
+        slides = relationships.xpath('//*[local-name()="Relationship"]').each_with_object({}) do |node, result|
+          next unless node['Type'].to_s.end_with?('/slide') && node['TargetMode'] != 'External'
+
+          target = PART_URI_PARSER.unescape(node['Target'].to_s)
+          part = target.start_with?('/') ? target.delete_prefix('/') : "ppt/#{target}"
+          part = Pathname.new(part).cleanpath.to_s
+          raise ExtractionError, 'Invalid slide path' unless part.start_with?('ppt/')
+
+          result[node['Id']] = part
+        end
+        presentation.xpath('//*[local-name()="sldIdLst"]/*[local-name()="sldId"]').each_with_index do |node, index|
+          relationship = node.attribute_nodes.find { |attribute| attribute.name == 'id' && attribute.namespace }
+          part = slides[relationship&.value]
+          raise ExtractionError, 'Missing slide relationship' unless part
+
+          slide = read_xml(zip, part)
+          slide.xpath('//a:p', 'a' => DRAWING_NS).each do |paragraph|
+            text = paragraph.xpath('.//a:t | .//a:br', 'a' => DRAWING_NS).map do |fragment|
+              fragment.name == 'br' ? "\n" : fragment.text
+            end.join
+            next if text.strip.empty?
+
+            yield(text: text, document_type: :pptx, slide: index + 1, location: "Slide #{index + 1}")
+          end
+        end
+      end
+    end
+  end
+
+  # 検索語を変えるたびに文書を再解析しないための、容量制限付きメモリキャッシュ。
+  # 完了した抽出のみ保持し、更新・置換されたファイルは再抽出する。
+  class DocumentTextCache
+    def initialize(extractor: DocumentTextExtractor.new, max_entries: 64, max_bytes: 16 * 1024 * 1024)
+      @extractor = extractor
+      @max_entries = max_entries
+      @max_bytes = max_bytes
+      @cache = {}
+    end
+
+    def each_record(path)
+      return enum_for(:each_record, path) unless block_given?
+
+      key = File.expand_path(path)
+      before = signature(path)
+      cached = @cache.delete(key)
+      if cached && cached[:signature] == before
+        @cache[key] = cached
+        cached[:records].each { |record| yield record }
+        return
+      end
+
+      records = []
+      bytes = 0
+      @extractor.each_record(path) do |record|
+        record = record.merge(search_text: record[:text].downcase).transform_values do |value|
+          value.is_a?(String) ? value.dup.freeze : value
+        end.freeze
+        bytes += record.values.sum { |value| value.is_a?(String) ? value.bytesize : 16 } + 64
+        if bytes <= @max_bytes
+          records << record if records
+        else
+          records = nil
+        end
+        yield record
+      end
+      return unless records && @max_entries.positive? && signature(path) == before
+
+      @cache.shift while !@cache.empty? && (@cache.length >= @max_entries || cache_bytes + bytes > @max_bytes)
+      @cache[key] = { signature: before, records: records.freeze, bytes: bytes }
+    end
+
+    private
+
+    def cache_bytes
+      @cache.values.sum { |entry| entry[:bytes] }
+    end
+
+    def signature(path)
+      stat = File.stat(path)
+      [stat.dev, stat.ino, stat.size, stat.mtime, stat.ctime]
+    end
+  end
+end