rufio 0.34.0 → 0.40.0

data/lib/rufio/command_mode_ui.rb

@@ -8,6 +8,8 @@ module Rufio
     def initialize(command_mode, dialog_renderer)
       @command_mode = command_mode
       @dialog_renderer = dialog_renderer
+      # 最後に表示したウィンドウの位置とサイズを保存
+      @last_window = nil
     end
 
     # 入力文字列に対する補完候補を取得
@@ -68,6 +70,9 @@ module Rufio
       # 中央位置を計算
       x, y = @dialog_renderer.calculate_center(width, height)
 
+      # ウィンドウの位置とサイズを保存
+      @last_window = { x: x, y: y, width: width, height: height }
+
       # フローティングウィンドウを描画
       @dialog_renderer.draw_floating_window(x, y, width, height, title, content_lines, {
                                                border_color: border_color,
@@ -136,6 +141,19 @@ module Rufio
       @dialog_renderer.clear_area(x, y, width, height)
     end
 
+    # コマンド入力プロンプトをクリア
+    def clear_prompt
+      return unless @last_window
+
+      @dialog_renderer.clear_area(
+        @last_window[:x],
+        @last_window[:y],
+        @last_window[:width],
+        @last_window[:height]
+      )
+      @last_window = nil
+    end
+
     private
 
     # 文字列配列の共通プレフィックスを見つける

data/lib/rufio/dialog_renderer.rb

@@ -7,6 +7,74 @@ module Rufio
   class DialogRenderer
     include TextUtils
 
+    # Phase 4: Screenバッファにフローティングウィンドウを描画
+    # @param screen [Screen] Screen buffer to draw to
+    # @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_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)
+    end
+
     # Draw a floating window with title, content, and customizable colors
     # @param x [Integer] X position (column)
     # @param y [Integer] Y position (row)

data/lib/rufio/keybind_handler.rb

@@ -545,7 +545,7 @@ module Rufio
     end
 
     def exit_request
-      true # request exit
+      show_exit_confirmation
     end
 
     def fzf_search
@@ -1117,6 +1117,53 @@ module Rufio
       end
     end
 
+    def show_exit_confirmation
+      # コンテンツの準備
+      title = 'Exit Confirmation'
+
+      content_lines = [
+        '',
+        'Are you sure you want to exit?',
+        '',
+        '  [Y]es - Exit',
+        '  [N]o  - Cancel',
+        ''
+      ]
+
+      # ダイアログのサイズ設定
+      dialog_width = CONFIRMATION_DIALOG_WIDTH
+      dialog_height = DIALOG_BORDER_HEIGHT + content_lines.length
+
+      # ダイアログの位置を中央に設定
+      x, y = @dialog_renderer.calculate_center(dialog_width, dialog_height)
+
+      # ダイアログの描画（終了は黄色で表示）
+      @dialog_renderer.draw_floating_window(x, y, dialog_width, dialog_height, title, content_lines, {
+                             border_color: "\e[33m",    # 黄色（注意）
+                             title_color: "\e[1;33m",   # 太字黄色
+                             content_color: "\e[37m"    # 白色
+                           })
+
+      # キー入力待機
+      loop do
+        input = STDIN.getch.downcase
+
+        case input
+        when 'y'
+          # ダイアログをクリア
+          @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+          @terminal_ui&.refresh_display # 画面を再描画
+          return true
+        when 'n', "\e", "\x03" # n, ESC, Ctrl+C
+          # ダイアログをクリア
+          @dialog_renderer.clear_area(x, y, dialog_width, dialog_height)
+          @terminal_ui&.refresh_display # 画面を再描画
+          return false
+        end
+        # 無効なキー入力の場合は再度ループ
+      end
+    end
+
     # パスを指定した長さに短縮
     def shorten_path(path, max_length)
       return path if path.length <= max_length
@@ -1455,7 +1502,7 @@ module Rufio
 
     # プロジェクトモード中のキー処理
     def handle_project_mode_key(key)
-      case key
+      result = case key
       when "\e" # ESC - ログモードならプロジェクトモードに戻る、そうでなければ終了
         if @in_log_mode
           exit_log_mode
@@ -1507,6 +1554,10 @@ module Rufio
       else
         false
       end
+
+      # キー処理後、プロジェクトモードの再描画をトリガー
+      @terminal_ui&.trigger_project_mode_redraw if result && @in_project_mode
+      result
     end
 
     # プロジェクトモード用のエントリ数取得

data/lib/rufio/plugins/stop.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Rufio
+  module Plugins
+    # Hello コマンドを提供するプラグイン
+    # Rubyコードで挨拶を返す簡単な例
+    class Stop < Plugin
+      def name
+        'Stop'
+      end
+
+      def description
+        'Rubyで実装された挨拶コマンドの例'
+      end
+
+      def commands
+        {
+          stop: method(:say_hello)
+        }
+      end
+
+      private
+
+      # 挨拶メッセージを返す
+      def say_hello
+        'stop 5seconds'
+        sleep 5
+        'done'
+      end
+    end
+  end
+end

data/lib/rufio/renderer.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Rufio
+  # Renderer class - Front buffer for double buffering
+  #
+  # Manages the front buffer (what's currently displayed on screen)
+  # and performs differential rendering by comparing with the back buffer (Screen).
+  #
+  # Features:
+  # - Diff rendering: Only updates changed lines
+  # - Cursor positioning: Uses ANSI escape codes
+  # - Flush control: Ensures all output is displayed
+  #
+  class Renderer
+    def initialize(width, height, output: STDOUT)
+      @width = width
+      @height = height
+      @front = Array.new(height) { " " * width }
+      @output = output
+    end
+
+    # Render the screen with differential updates
+    #
+    # @param screen [Screen] The back buffer to render
+    def render(screen)
+      # Phase1: Only process dirty rows (rows that have changed)
+      screen.dirty_rows.each do |y|
+        line = screen.row(y)
+        next if line == @front[y]  # Skip if content is actually the same
+
+        # Move cursor to line y (1-indexed) and output the line
+        @output.print "\e[#{y + 1};1H#{line}"
+        @front[y] = line
+      end
+
+      # Phase1: Clear dirty tracking after rendering
+      screen.clear_dirty
+      @output.flush
+    end
+
+    # Resize the front buffer
+    #
+    # @param width [Integer] New width
+    # @param height [Integer] New height
+    def resize(width, height)
+      @width = width
+      @height = height
+      @front = Array.new(height) { " " * width }
+
+      # Clear entire screen
+      @output.print "\e[2J\e[H"
+      @output.flush
+    end
+
+    # Clear the front buffer and screen
+    def clear
+      @front = Array.new(@height) { " " * @width }
+
+      # Clear screen and move cursor to home
+      @output.print "\e[2J\e[H"
+      @output.flush
+    end
+  end
+end

data/lib/rufio/screen.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'set'
+
+module Rufio
+  # Screen class - Back buffer for double buffering
+  #
+  # Manages a virtual screen buffer where each cell contains:
+  # - Character
+  # - Foreground color (ANSI code)
+  # - Background color (ANSI code)
+  # - Display width (for multibyte characters)
+  #
+  # Supports:
+  # - ASCII characters (width = 1)
+  # - Full-width characters (width = 2, e.g., Japanese, Chinese)
+  # - Emoji (width = 2+)
+  #
+  # Phase1 Optimizations:
+  # - Width pre-calculation (computed once in put method)
+  # - Dirty row tracking (only render changed rows)
+  # - Optimized format_cell (String.new with capacity)
+  # - Optimized row generation (width accumulation, no ANSI strip)
+  # - Minimal ANSI stripping (only once in put_string)
+  #
+  class Screen
+    attr_reader :width, :height
+
+    def initialize(width, height)
+      @width = width
+      @height = height
+      @cells = Array.new(height) { Array.new(width) { default_cell } }
+      @dirty_rows = Set.new  # Phase1: Dirty row tracking
+    end
+
+    # Put a single character at (x, y) with optional color
+    #
+    # @param x [Integer] X position (0-indexed)
+    # @param y [Integer] Y position (0-indexed)
+    # @param char [String] Character to put
+    # @param fg [String, nil] Foreground ANSI color code
+    # @param bg [String, nil] Background ANSI color code
+    # @param width [Integer, nil] Display width (auto-detected if not provided)
+    def put(x, y, char, fg: nil, bg: nil, width: nil)
+      return if out_of_bounds?(x, y)
+
+      # Phase1: Width is calculated once here (not in rendering loop)
+      char_width = width || TextUtils.display_width(char)
+      @cells[y][x] = {
+        char: char,
+        fg: fg,
+        bg: bg,
+        width: char_width
+      }
+
+      # Phase1: Mark row as dirty
+      @dirty_rows.add(y)
+
+      # For full-width characters, mark the next cell as occupied
+      if char_width >= 2 && x + 1 < @width
+        (char_width - 1).times do |offset|
+          next_x = x + 1 + offset
+          break if next_x >= @width
+          @cells[y][next_x] = {
+            char: '',
+            fg: nil,
+            bg: nil,
+            width: 0
+          }
+        end
+      end
+    end
+
+    # Put a string starting at (x, y)
+    #
+    # @param x [Integer] Starting X position
+    # @param y [Integer] Y position
+    # @param str [String] String to put (ANSI codes will be stripped)
+    # @param fg [String, nil] Foreground ANSI color code
+    # @param bg [String, nil] Background ANSI color code
+    def put_string(x, y, str, fg: nil, bg: nil)
+      return if out_of_bounds?(x, y)
+
+      # Phase1: ANSI stripping only once (minimal processing)
+      # Only strip if the string contains ANSI codes
+      clean_str = str.include?("\e") ? ColorHelper.strip_ansi(str) : str
+
+      current_x = x
+      clean_str.each_char do |char|
+        break if current_x >= @width
+
+        char_width = TextUtils.display_width(char)
+        put(current_x, y, char, fg: fg, bg: bg, width: char_width)
+        current_x += char_width
+      end
+    end
+
+    # Get the cell at (x, y)
+    #
+    # @param x [Integer] X position
+    # @param y [Integer] Y position
+    # @return [Hash] Cell data {char:, fg:, bg:, width:}
+    def get_cell(x, y)
+      return default_cell if out_of_bounds?(x, y)
+      @cells[y][x]
+    end
+
+    # Get a row as a formatted string
+    #
+    # @param y [Integer] Row number
+    # @return [String] Formatted row with ANSI codes
+    def row(y)
+      return " " * @width if y < 0 || y >= @height
+
+      # Phase1: Pre-allocate string capacity for better performance
+      result = String.new(capacity: @width * 20)
+      current_width = 0  # Phase1: Accumulate width from cells (no recalculation)
+
+      @cells[y].each do |cell|
+        # Skip marker cells for full-width characters
+        next if cell[:width] == 0
+
+        result << format_cell(cell)
+        current_width += cell[:width]  # Phase1: Use pre-calculated width
+      end
+
+      # Pad the row to full width
+      # Phase1: No ANSI stripping or width recalculation needed
+      if current_width < @width
+        result << (" " * (@width - current_width))
+      end
+
+      result
+    end
+
+    # Clear the entire screen
+    def clear
+      @cells.each do |row|
+        row.fill { default_cell }
+      end
+      # Phase1: Clear dirty rows after full clear
+      @dirty_rows.clear
+    end
+
+    # Phase1: Get dirty rows (rows that have been modified since last clear)
+    #
+    # @return [Array<Integer>] Array of dirty row indices
+    def dirty_rows
+      @dirty_rows.to_a
+    end
+
+    # Phase1: Clear dirty row tracking
+    def clear_dirty
+      @dirty_rows.clear
+    end
+
+    private
+
+    def default_cell
+      { char: ' ', fg: nil, bg: nil, width: 1 }
+    end
+
+    def out_of_bounds?(x, y)
+      x < 0 || y < 0 || x >= @width || y >= @height
+    end
+
+    def format_cell(cell)
+      char = cell[:char]
+      fg = cell[:fg]
+      bg = cell[:bg]
+
+      # Phase1: Fast path for cells without color
+      return char if fg.nil? && bg.nil?
+
+      # Phase1: String builder with pre-allocated capacity (no array generation)
+      result = String.new(capacity: 30)
+      result << fg if fg
+      result << bg if bg
+      result << char
+      result << "\e[0m"
+      result
+    end
+  end
+end