rufio 0.40.1 → 0.50.0

data/lib/rufio/renderer.rb

@@ -22,20 +22,33 @@ module Rufio
     # Render the screen with differential updates
     #
     # @param screen [Screen] The back buffer to render
+    # @return [Boolean] true if rendering was performed, false if skipped
     def render(screen)
+      # CPU最適化: Dirty rowsが空の場合は完全にスキップ
+      dirty = screen.dirty_rows
+      if dirty.empty?
+        return false
+      end
+
       # Phase1: Only process dirty rows (rows that have changed)
-      screen.dirty_rows.each do |y|
+      rendered_count = 0
+      dirty.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
+        rendered_count += 1
       end
 
       # Phase1: Clear dirty tracking after rendering
       screen.clear_dirty
-      @output.flush
+
+      # Only flush if we actually rendered something
+      @output.flush if rendered_count > 0
+
+      true
     end
 
     # Resize the front buffer

data/lib/rufio/script_executor.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require "open3"
+require "timeout"
+
+module Rufio
+  # スクリプトを安全に実行するクラス
+  class ScriptExecutor
+    class << self
+      # スクリプトを実行する
+      # @param interpreter [String] インタープリタ（ruby, python3, bashなど）
+      # @param script_path [String] スクリプトのパス
+      # @param args [Array<String>] スクリプトへの引数
+      # @param timeout [Numeric, nil] タイムアウト秒数（nilの場合は無制限）
+      # @param chdir [String, nil] 作業ディレクトリ
+      # @param env [Hash, nil] 環境変数
+      # @return [Hash] 実行結果
+      def execute(interpreter, script_path, args = [], timeout: nil, chdir: nil, env: nil)
+        # 配列ベースのコマンドを構築（シェルインジェクション防止）
+        command = [interpreter, script_path, *args]
+
+        # オプションを構築
+        options = {}
+        options[:chdir] = chdir if chdir
+        # 環境変数をマージ（既存の環境変数を保持）
+        spawn_env = env || {}
+
+        execute_with_options(command, spawn_env, options, timeout)
+      rescue StandardError => e
+        build_error_result(e)
+      end
+
+      # DslCommandを実行する（タイプ別に分岐）
+      # @param dsl_command [DslCommand] 実行するDSLコマンド
+      # @param args [Array<String>] 追加の引数
+      # @param timeout [Numeric, nil] タイムアウト秒数
+      # @param chdir [String, nil] 作業ディレクトリ
+      # @param env [Hash, nil] 環境変数
+      # @return [Hash] 実行結果
+      def execute_command(dsl_command, args = [], timeout: nil, chdir: nil, env: nil)
+        case dsl_command.command_type
+        when :ruby
+          execute_ruby(dsl_command)
+        when :shell
+          execute_shell(dsl_command, timeout: timeout, chdir: chdir, env: env)
+        else
+          exec_args = dsl_command.to_execution_args
+          execute(exec_args[0], exec_args[1], args, timeout: timeout, chdir: chdir, env: env)
+        end
+      end
+
+      # inline Rubyコマンドを実行する
+      # @param dsl_command [DslCommand] 実行するDSLコマンド
+      # @return [Hash] 実行結果
+      def execute_ruby(dsl_command)
+        result = dsl_command.ruby_block.call
+        {
+          success: true,
+          exit_code: 0,
+          stdout: result.to_s,
+          stderr: "",
+          timeout: false
+        }
+      rescue StandardError => e
+        {
+          success: false,
+          exit_code: 1,
+          stdout: "",
+          stderr: "",
+          error: e.message,
+          timeout: false
+        }
+      end
+
+      # inline シェルコマンドを実行する
+      # @param dsl_command [DslCommand] 実行するDSLコマンド
+      # @param timeout [Numeric, nil] タイムアウト秒数
+      # @param chdir [String, nil] 作業ディレクトリ
+      # @param env [Hash, nil] 環境変数
+      # @return [Hash] 実行結果
+      def execute_shell(dsl_command, timeout: nil, chdir: nil, env: nil)
+        options = {}
+        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
+      rescue StandardError => e
+        build_error_result(e)
+      end
+
+      private
+
+      # コマンドを実行し、結果を返す
+      # @param command [Array<String>] 実行するコマンド
+      # @param env [Hash] 環境変数
+      # @param options [Hash] Open3オプション
+      # @param timeout_sec [Numeric, nil] タイムアウト秒数
+      # @return [Hash] 実行結果
+      def execute_with_options(command, env, options, timeout_sec)
+        if timeout_sec
+          execute_with_timeout(command, env, options, timeout_sec)
+        else
+          execute_without_timeout(command, env, options)
+        end
+      end
+
+      # タイムアウト付きで実行
+      def execute_with_timeout(command, env, options, timeout_sec)
+        stdout = ""
+        stderr = ""
+        status = nil
+        timed_out = false
+        pid = nil
+
+        begin
+          Timeout.timeout(timeout_sec) do
+            stdin, stdout_io, stderr_io, wait_thread = Open3.popen3(env, *command, **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_without_timeout(command, env, options)
+        stdout, stderr, status = Open3.capture3(env, *command, **options)
+
+        {
+          success: status.success?,
+          exit_code: status.exitstatus,
+          stdout: stdout,
+          stderr: stderr,
+          timeout: false
+        }
+      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
+            stdin, stdout_io, stderr_io, wait_thread = Open3.popen3(env, shell_command, **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)
+        stdout, stderr, status = Open3.capture3(env, shell_command, **options)
+
+        {
+          success: status.success?,
+          exit_code: status.exitstatus,
+          stdout: stdout,
+          stderr: stderr,
+          timeout: false
+        }
+      end
+
+      # エラー結果を構築
+      def build_error_result(error)
+        {
+          success: false,
+          exit_code: 1,
+          stdout: "",
+          stderr: "",
+          error: error.message,
+          timeout: false
+        }
+      end
+    end
+  end
+end

data/lib/rufio/terminal_ui.rb

@@ -71,6 +71,10 @@ module Rufio
       @cached_bookmarks = nil
       @cached_bookmark_time = nil
       @bookmark_cache_ttl = 1.0  # 1秒間キャッシュ
+
+      # Command execution lamp (footer indicator)
+      @completion_lamp_message = nil
+      @completion_lamp_time = nil
     end
 
     def start(directory_listing, keybind_handler, file_preview, background_executor = nil)
@@ -159,75 +163,143 @@ module Rufio
       puts ConfigLoader.message('app.terminated')
     end
 
-    # ゲームループパターンのmain_loop
+    # ゲームループパターンのmain_loop（CPU最適化版：フレームスキップ対応）
     # UPDATE → DRAW → RENDER → SLEEP のサイクル
+    # 変更がない場合は描画をスキップしてCPU使用率を削減
     def main_loop
-      fps = 60
-      interval = 1.0 / fps
+      # CPU最適化: 固定FPSをやめて、イベントドリブンに変更
+      # 最小スリープ時間（入力チェック間隔）
+      min_sleep_interval = 0.0333  # 30FPS（約33.33ms/フレーム）
+      check_interval = 0.1  # バックグラウンドタスクのチェック間隔
 
       # Phase 3: Screen/Rendererを初期化
       @screen = Screen.new(@screen_width, @screen_height)
       @renderer = Renderer.new(@screen_width, @screen_height)
 
+      # 初回描画
+      @screen.clear
+      draw_screen_to_buffer(@screen, nil, nil)
+      @renderer.render(@screen)
+
       last_notification_check = Time.now
+      last_lamp_check = Time.now
       notification_message = nil
       notification_time = nil
+      previous_notification = nil
+      previous_lamp_message = @completion_lamp_message
 
       # FPS計測用
       frame_times = []
       last_frame_time = Time.now
       current_fps = 0.0
+      last_fps_update = Time.now
+
+      # 再描画フラグ
+      needs_redraw = false
 
       while @running
         start = Time.now
 
+        # FPS計算（毎フレームで記録）- ループの最初で計測してsleep時間を含める
+        if @test_mode
+          frame_time = start - last_frame_time
+          last_frame_time = start
+          frame_times << frame_time
+          frame_times.shift if frame_times.size > 60  # 直近60フレームで平均
+
+          # FPS表示の更新は1秒ごと
+          if (start - last_fps_update) > 1.0
+            avg_frame_time = frame_times.sum / frame_times.size
+            current_fps = 1.0 / avg_frame_time if avg_frame_time > 0
+            last_fps_update = start
+          end
+
+          # test_modeでは毎フレーム描画してFPS計測の精度を上げる
+          needs_redraw = true
+        end
+
         # UPDATE phase - ノンブロッキング入力処理
-        handle_input_nonblocking
+        # 入力があった場合は再描画が必要
+        had_input = handle_input_nonblocking
+        needs_redraw = true if had_input
 
-        # バックグラウンドコマンドの完了チェック（0.5秒ごと）
-        if @background_executor && (Time.now - last_notification_check) > 0.5
+        # バックグラウンドコマンドの完了チェック（0.1秒ごと）
+        if @background_executor && (start - last_notification_check) > check_interval
           if !@background_executor.running? && @background_executor.get_completion_message
-            notification_message = @background_executor.get_completion_message
-            notification_time = Time.now
+            completion_msg = @background_executor.get_completion_message
+            # 通知メッセージとして表示
+            notification_message = completion_msg
+            notification_time = start
+            # フッターのランプ表示用にも設定
+            @completion_lamp_message = completion_msg
+            @completion_lamp_time = start
             @background_executor.instance_variable_set(:@completion_message, nil)  # メッセージをクリア
+            needs_redraw = true
           end
-          last_notification_check = Time.now
+          last_notification_check = start
         end
 
-        # FPS計算（移動平均）
-        if @test_mode
-          frame_time = Time.now - last_frame_time
-          frame_times << frame_time
-          frame_times.shift if frame_times.size > 60  # 直近60フレームで平均
-          avg_frame_time = frame_times.sum / frame_times.size
-          current_fps = 1.0 / avg_frame_time if avg_frame_time > 0
-          last_frame_time = Time.now
+        # バックグラウンドコマンドの実行状態が変わった場合も再描画
+        if @background_executor
+          current_running = @background_executor.running?
+          if @last_bg_running != current_running
+            @last_bg_running = current_running
+            needs_redraw = true
+          end
         end
 
-        # DRAW phase - Screenバッファに描画
-        @screen.clear
-        if notification_message && (Time.now - notification_time) < 3.0
-          draw_screen_to_buffer(@screen, notification_message, current_fps)
-        else
-          notification_message = nil if notification_message
-          draw_screen_to_buffer(@screen, nil, current_fps)
+        # 完了ランプの表示状態をチェック（0.5秒ごと）
+        if (start - last_lamp_check) > 0.5
+          current_lamp = @completion_lamp_message
+          if current_lamp != previous_lamp_message
+            previous_lamp_message = current_lamp
+            needs_redraw = true
+          end
+          # 完了ランプのタイムアウトチェック
+          if @completion_lamp_message && @completion_lamp_time && (start - @completion_lamp_time) >= 3.0
+            @completion_lamp_message = nil
+            needs_redraw = true
+          end
+          last_lamp_check = start
         end
 
-        # RENDER phase - 差分レンダリング
-        @renderer.render(@screen)
+        # 通知メッセージの変化をチェック
+        current_notification = notification_message && (start - notification_time) < 3.0 ? notification_message : nil
+        if current_notification != previous_notification
+          previous_notification = current_notification
+          notification_message = nil if current_notification.nil?
+          needs_redraw = true
+        end
+
+        # DRAW & RENDER phase - 変更があった場合のみ描画
+        if needs_redraw
+          # Screenバッファに描画（clearは呼ばない。必要な部分だけ更新）
+          if notification_message && (start - notification_time) < 3.0
+            draw_screen_to_buffer(@screen, notification_message, current_fps)
+          else
+            draw_screen_to_buffer(@screen, nil, current_fps)
+          end
+
+          # 差分レンダリング（dirty rowsのみ）
+          @renderer.render(@screen)
+
+          # 描画後にカーソルを画面外に移動
+          if !@command_mode_active
+            print "\e[#{@screen_height};#{@screen_width}H"
+          end
+
+          needs_redraw = false
+        end
 
         # コマンドモードがアクティブな場合はフローティングウィンドウを表示
         # Phase 4: 暫定的に直接描画（Screenバッファ外）
         if @command_mode_active
           @command_mode_ui.show_input_prompt(@command_input)
-        else
-          # カーソルを画面外に移動
-          print "\e[#{@screen_height};#{@screen_width}H"
         end
 
-        # SLEEP phase - FPS制御
+        # SLEEP phase - CPU使用率削減のため適切にスリープ
         elapsed = Time.now - start
-        sleep_time = [interval - elapsed, 0].max
+        sleep_time = [min_sleep_interval - elapsed, 0].max
         sleep sleep_time if sleep_time > 0
       end
     end
@@ -829,13 +901,36 @@ module Rufio
         end
         bookmark_text = bookmark_parts.join(" ")
 
-        # 右側の情報: FPS（test modeの時のみ）| ?:help
+        # 右側の情報: コマンド実行ランプ | FPS（test modeの時のみ）| ?:help
+        right_parts = []
+
+        # バックグラウンドコマンドの実行状態をランプで表示
+        if @background_executor
+          if @background_executor.running?
+            # 実行中ランプ（緑色の回転矢印）
+            command_name = @background_executor.current_command || "処理中"
+            right_parts << "\e[32m🔄\e[0m #{command_name}"
+          elsif @completion_lamp_message && @completion_lamp_time
+            # 完了ランプ（3秒間表示）
+            if (Time.now - @completion_lamp_time) < 3.0
+              right_parts << @completion_lamp_message
+            else
+              @completion_lamp_message = nil
+              @completion_lamp_time = nil
+            end
+          end
+        end
+
+        # FPS表示（test modeの時のみ）
         if @test_mode && fps
-          right_info = "#{fps.round(1)} FPS | ?:help"
-        else
-          right_info = "?:help"
+          right_parts << "#{fps.round(1)} FPS"
         end
 
+        # ヘルプ表示
+        right_parts << "?:help"
+
+        right_info = right_parts.join(" | ")
+
         # ブックマーク一覧を利用可能な幅に収める
         available_width = @screen_width - right_info.length - 3
         if bookmark_text.length > available_width && available_width > 3
@@ -918,26 +1013,26 @@ module Rufio
     # ノンブロッキング入力処理（ゲームループ用）
     # IO.selectでタイムアウト付きで入力をチェック
     def handle_input_nonblocking
-      # 1msタイムアウトで入力待ち（60FPS = 16.67ms/frame）
-      ready = IO.select([STDIN], nil, nil, 0.001)
-      return unless ready
+      # 0msタイムアウトで即座にチェック（30FPS = 33.33ms/frame）
+      ready = IO.select([STDIN], nil, nil, 0)
+      return false unless ready
 
       begin
         # read_nonblockを使ってノンブロッキングで1文字読み取る
         input = STDIN.read_nonblock(1)
       rescue IO::WaitReadable, IO::EAGAINWaitReadable
         # 入力が利用できない
-        return
+        return false
       rescue Errno::ENOTTY, Errno::ENODEV
         # ターミナルでない環境
-        return
+        return false
       end
 
       # コマンドモードがアクティブな場合は、エスケープシーケンス処理をスキップ
       # ESCキーをそのまま handle_command_input に渡す
       if @command_mode_active
         handle_command_input(input)
-        return
+        return true
       end
 
       # 特殊キーの処理（エスケープシーケンス）（コマンドモード外のみ）
@@ -967,12 +1062,15 @@ module Rufio
       end
 
       # キーバインドハンドラーに処理を委譲
-      @keybind_handler.handle_key(input) if input
+      result = @keybind_handler.handle_key(input) if input
 
-      # 終了処理（qキーのみ）
-      if input == 'q'
+      # 終了処理（qキーのみ、確認ダイアログの結果を確認）
+      if input == 'q' && result == true
         @running = false
       end
+
+      # 入力があったことを返す
+      true
     end
 
     def handle_input
@@ -1028,10 +1126,10 @@ module Rufio
       end
 
       # キーバインドハンドラーに処理を委譲
-      _result = @keybind_handler.handle_key(input)
+      result = @keybind_handler.handle_key(input)
 
-      # 終了処理（qキーのみ）
-      if input == 'q'
+      # 終了処理（qキーのみ、確認ダイアログの結果を確認）
+      if input == 'q' && result == true
         @running = false
       end
     end

data/lib/rufio/text_utils.rb

@@ -126,8 +126,17 @@ module Rufio
 
       wrapped = []
       lines.each do |line|
-        # Remove trailing whitespace
-        line = line.rstrip
+        # Handle encoding errors: scrub invalid UTF-8 sequences
+        begin
+          # Force UTF-8 encoding and replace invalid bytes
+          line = line.encode('UTF-8', invalid: :replace, undef: :replace, replace: '?')
+          # Remove trailing whitespace
+          line = line.rstrip
+        rescue EncodingError, ArgumentError => e
+          # If encoding fails completely, skip this line
+          wrapped << '[encoding error]'
+          next
+        end
 
         # If line is empty, keep it
         if line.empty?
@@ -136,31 +145,45 @@ module Rufio
         end
 
         # If line fits within max_width, keep it as is
-        if display_width(line) <= max_width
-          wrapped << line
-          next
+        begin
+          if display_width(line) <= max_width
+            wrapped << line
+            next
+          end
+        rescue ArgumentError => e
+          # If display_width fails, just truncate by byte length
+          if line.bytesize <= max_width
+            wrapped << line
+            next
+          end
         end
 
         # Split long lines
         current_line = []
         current_width = 0
 
-        line.each_char do |char|
-          cw = char_width(char)
-
-          if current_width + cw > max_width
-            # Start a new line
-            wrapped << current_line.join
-            current_line = [char]
-            current_width = cw
-          else
-            current_line << char
-            current_width += cw
+        begin
+          line.each_char do |char|
+            cw = char_width(char)
+
+            if current_width + cw > max_width
+              # Start a new line
+              wrapped << current_line.join
+              current_line = [char]
+              current_width = cw
+            else
+              current_line << char
+              current_width += cw
+            end
           end
-        end
 
-        # Add remaining characters
-        wrapped << current_line.join unless current_line.empty?
+          # Add remaining characters
+          wrapped << current_line.join unless current_line.empty?
+        rescue ArgumentError, EncodingError => e
+          # If character iteration fails, just add the line truncated
+          truncated = line.byteslice(0, [max_width, line.bytesize].min)
+          wrapped << (truncated || line)
+        end
       end
 
       wrapped

data/lib/rufio/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Rufio
-  VERSION = '0.40.1'
+  VERSION = '0.50.0'
 end