kward 0.70.0 → 0.71.0

data/lib/kward/prompt_interface/prompt_renderer.rb

@@ -6,25 +6,44 @@ module Kward
     module PromptRenderer
       private
 
-      def render_prompt_locked
+      def render_prompt_locked(synchronized: false)
         return unless @started && @asking
 
-        with_synchronized_output_locked do
-          handle_resize_locked
-          width, height = screen_size
-          rows, cursor_row, cursor_col = composer_layout(width, height)
-          ensure_scroll_region_locked(rows.length, width: width, height: height)
-          @rendered_rows = rows.length
-          render_composer_rows_locked(rows, height: height)
-          @cursor_rendered_row = cursor_row
-          @last_width = width
-          @last_height = height
-          move_to_screen(composer_top_row(height) + cursor_row, cursor_col + 1)
-          render_cursor_visibility_locked
+        width, height = screen_size
+        if width != @last_width || height != @last_height
+          with_synchronized_output_locked { render_prompt_body_locked }
+          @output_io.flush
+          return
+        end
+
+        rows, cursor_row, cursor_col = composer_layout(width, height)
+        synchronized ||= rows.length != @reserved_rows
+        if synchronized
+          with_synchronized_output_locked { render_prompt_layout_locked(rows, cursor_row, cursor_col, width, height) }
+        else
+          render_prompt_layout_locked(rows, cursor_row, cursor_col, width, height)
         end
         @output_io.flush
       end
 
+      def render_prompt_body_locked
+        handle_resize_locked
+        width, height = screen_size
+        rows, cursor_row, cursor_col = composer_layout(width, height)
+        render_prompt_layout_locked(rows, cursor_row, cursor_col, width, height)
+      end
+
+      def render_prompt_layout_locked(rows, cursor_row, cursor_col, width, height)
+        ensure_scroll_region_locked(rows.length, width: width, height: height)
+        @rendered_rows = rows.length
+        render_composer_rows_locked(rows, height: height)
+        @cursor_rendered_row = cursor_row
+        @last_width = width
+        @last_height = height
+        move_to_screen(composer_top_row(height) + cursor_row, cursor_col + 1)
+        render_cursor_visibility_locked
+      end
+
       def render_prompt_after_output_locked
         render_prompt_locked
       end

data/lib/kward/prompt_interface/question_prompt.rb

@@ -8,13 +8,7 @@ module Kward
 
       def ask_single_user_question(question, index, total)
         @mutex.synchronize do
-          @prompt_label = "Answer>"
-          self.composer_input = ""
-          self.composer_cursor = 0
-          @pending_keys.clear
-          @asking = true
-          @busy = false
-          @queued_count = 0
+          prepare_modal_input_locked("Answer>")
           @question_state = {
             question: question[:question] || question["question"],
             header: question[:header] || question["header"],
@@ -23,7 +17,6 @@ module Kward
             index: index,
             total: total
           }
-          reset_history_navigation
           render_prompt_locked
         end
 
@@ -37,6 +30,7 @@ module Kward
               render_prompt_locked if resized || footer_refreshed
             else
               result = handle_question_key(key)
+              result = drain_pending_question_keys_locked(result)
               render_prompt_locked unless result.is_a?(Hash) || result == SELECT_CANCEL
             end
           end
@@ -47,6 +41,13 @@ module Kward
         end
       end
 
+      def drain_pending_question_keys_locked(result)
+        until result.is_a?(Hash) || result == SELECT_CANCEL || @pending_keys.empty?
+          result = handle_question_key(@pending_keys.shift)
+        end
+        result
+      end
+
       def begin_question_prompt_state
         {
           prompt_label: @prompt_label,
@@ -101,13 +102,13 @@ module Kward
         when :delete
           question_delete_at_cursor
         when :left
-          self.composer_cursor -= 1 if composer_cursor.positive?
+          @composer.move_cursor_left
         when :right
-          self.composer_cursor += 1 if composer_cursor < composer_input.length
+          @composer.move_cursor_right
         when :home
-          self.composer_cursor = 0
+          @composer.move_to_start_of_line
         when :end
-          self.composer_cursor = composer_input.length
+          @composer.move_to_end_of_line
         when :up
           question_previous_choice
         when :down
@@ -127,12 +128,11 @@ module Kward
       end
 
       def handle_question_csi_u_key(key)
-        match = key.to_s.match(/\A\e\[(\d+)(?:;([\d:]+))?u/)
-        return false unless match
+        sequence = parse_csi_u_key(key)
+        return false unless sequence
 
-        sequence = match[0]
-        code = match[1].to_i
-        queue_pending_keys(key[sequence.length..]) if key.length > sequence.length
+        code = sequence[:code]
+        queue_pending_keys(sequence[:remaining]) if sequence[:remaining] && !sequence[:remaining].empty?
 
         case code
         when 13
@@ -148,38 +148,34 @@ module Kward
       end
 
       def handle_question_escape_sequence
-        sequence = read_pending_escape_sequence
-        return SELECT_CANCEL if sequence.empty?
+        pending_sequence = read_pending_escape_sequence
+        return SELECT_CANCEL if pending_sequence.empty?
+
+        full_sequence = "\e#{pending_sequence}"
+        sequence = next_key_token(full_sequence)
+        queue_pending_keys(full_sequence[sequence.length..]) if full_sequence.length > sequence.length
+        return SELECT_CANCEL if sequence == "\e"
 
-        key_name = @reader.console.keys["\e#{sequence}"]
+        key_name = @reader.console.keys[sequence]
         case key_name
         when :up
           question_previous_choice
         when :down
           question_next_choice
         when :left
-          self.composer_cursor -= 1 if composer_cursor.positive?
+          @composer.move_cursor_left
         when :right
-          self.composer_cursor += 1 if composer_cursor < composer_input.length
+          @composer.move_cursor_right
         end
         true
       end
 
       def handle_question_bracketed_paste_key(key)
-        text = key.to_s
-        return false unless text.start_with?(BRACKETED_PASTE_START)
-
-        pasted = text[BRACKETED_PASTE_START.length..] || ""
-        until pasted.include?(BRACKETED_PASTE_END)
-          chunk = @reader.read_keypress(echo: false, raw: true)
-          break if chunk.nil?
-
-          pasted << chunk.to_s
-        end
+        paste = read_bracketed_paste(key)
+        return false unless paste
 
-        content, remaining = pasted.split(BRACKETED_PASTE_END, 2)
-        question_insert_string(normalize_paste(content || ""))
-        queue_pending_keys(remaining) if remaining && !remaining.empty?
+        question_insert_string(normalize_paste(paste[:content]))
+        queue_pending_keys(paste[:remaining]) if paste[:remaining] && !paste[:remaining].empty?
         true
       end
 
@@ -251,23 +247,19 @@ module Kward
       def question_insert_string(string)
         return if string.empty?
 
-        self.composer_input = composer_input[0...composer_cursor] + string + composer_input[composer_cursor..]
-        self.composer_cursor += string.length
+        @composer.insert_string(string)
         @question_state[:selection_index] = question_choices.length - 1 if @question_state
       end
 
       def question_delete_before_cursor
-        return unless composer_cursor.positive?
+        return unless @composer.delete_before_cursor
 
-        self.composer_input = composer_input[0...(composer_cursor - 1)] + composer_input[composer_cursor..]
-        self.composer_cursor -= 1
         @question_state[:selection_index] = question_choices.length - 1 if @question_state && !composer_input.empty?
       end
 
       def question_delete_at_cursor
-        return unless composer_cursor < composer_input.length
+        return unless @composer.delete_at_cursor
 
-        self.composer_input = composer_input[0...composer_cursor] + composer_input[(composer_cursor + 1)..]
         @question_state[:selection_index] = question_choices.length - 1 if @question_state && !composer_input.empty?
       end
 

data/lib/kward/prompt_interface/runtime_state.rb

@@ -17,7 +17,7 @@ module Kward
       end
 
       def tick_spinner_locked
-        return false unless @busy && @queued_count.zero? && @started && @asking
+        return false unless spinner_active?
 
         now = monotonic_now
         elapsed = now - @last_spinner_tick
@@ -33,6 +33,11 @@ module Kward
         SPINNER_FRAMES[@spinner_frame_index % SPINNER_FRAMES.length]
       end
 
+      def spinner_active?
+        busy = @busy || (@select_state && @select_state[:busy_activity])
+        busy && @queued_count.zero? && @started && @asking
+      end
+
       def tick_footer_locked
         return false unless @footer && @started && @asking
 

data/lib/kward/prompt_interface/screen.rb

@@ -55,6 +55,7 @@ module Kward
 
       def render_cursor_visibility_locked
         visible = !(@question_state && !selected_question_choice&.fetch(:custom, false))
+        visible = select_editing_active? if @select_state
         set_cursor_visible_locked(visible)
       end