asktty 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7afce23120ce01740dd6c9f0e405080565efd3c22546361508611e8573a051aa
-  data.tar.gz: 8c2e75af399a24f63d9230112acbb07152d604f00da0d0cdc95098b9cf48fb31
+  metadata.gz: 1ea8ecccbeef5886609092cc74ef77888a4c9a467947be62f42137e9c5174063
+  data.tar.gz: 7e26f19e4b7352daab2d9878f644e4724b48537bd30745592df4057813cbcc62
 SHA512:
-  metadata.gz: 2c164a8cd20c460cf1baa0739244155c2f24f862f6b987617245eeac91e1e55938b88d8c109d7ce87df1c05f1181c04e4e983c5ac2febdc8442ecb79364c5d84
-  data.tar.gz: 17f6e9e671a4ac84b1cb358f7648c03561b9212f06f4cafa7190f002e4c67f552b03f866236104da19cc772f365b3e147b63fdf03b3acc364a830d4136f275f1
+  metadata.gz: 0aaf2802c3d81ff02d459d7e74732ef44c3e4a5b6c57ef353bfec622e9bcaaa0c78d353640dda23a5dd9f2415e92bc49dc8a9c81d1829651784b9990f82a40c0
+  data.tar.gz: 9f232b5466f6b6cd57ec34c1ec7f2e7d257bc9c0b169bd0a240b22feedff53d692af41170085975ac8b65f1340936ae2c2ebc37214b894d1b2ff1d8b348e2fc0

data/README.md

@@ -97,6 +97,12 @@ name = AskTTY::InputPrompt.ask(title: "Name") do |value|
 end
 ```
 
+Validation runs after each edit or selection change. A paste is one edit. If the value has not been validated yet,
+the first submission validates it. Submissions reuse the result until the value changes.
+Moving the focus in a multi-select prompt does not validate until an item is toggled or the selection is submitted.
+Keep validators free of side effects and use checks whose result depends on the supplied value.
+Exceptions raised by the block propagate to the caller after terminal cleanup.
+
 ## Examples
 
 Run the interactive example from the project root:

data/lib/asktty/internal/ansi_style.rb

@@ -3,52 +3,29 @@
 module AskTTY
   module Internal
     module ANSIStyle
-      module_function
-
-      def style(text, foreground: nil, background: nil)
-        codes = []
-        codes << "38;5;#{foreground}" if foreground
-        codes << "48;5;#{background}" if background
-
-        return text.to_s if codes.empty?
-
-        "\e[#{codes.join(';')}m#{text}\e[0m"
-      end
+      PALETTE = {
+        title: "38;5;6",
+        text: "38;5;7",
+        prompt: "38;5;3",
+        selected: "38;5;2",
+        muted: "38;5;8",
+        error: "38;5;9",
+        focused_button: "38;5;0;48;5;2",
+        blurred_button: "38;5;7;48;5;0",
+        cursor: "38;5;7;48;5;2",
+        placeholder_cursor: "38;5;8;48;5;2"
+      }.freeze
+
+      private_constant :PALETTE
 
-      def title(text)
-        style(text, foreground: 6)
-      end
-
-      def muted(text)
-        style(text, foreground: 8)
-      end
-
-      def prompt(text)
-        style(text, foreground: 3)
-      end
-
-      def text(text)
-        style(text, foreground: 7)
-      end
-
-      def selected(text)
-        style(text, foreground: 2)
-      end
-
-      def focused_button(text)
-        style("  #{text}  ", foreground: 0, background: 2)
-      end
-
-      def blurred_button(text)
-        style("  #{text}  ", foreground: 7, background: 0)
-      end
+      module_function
 
-      def cursor(text = " ")
-        style(text, foreground: 7, background: 2)
+      def apply(text, role)
+        "\e[#{PALETTE.fetch(role)}m#{text}\e[0m"
       end
 
-      def error(text)
-        style(text, foreground: 9)
+      def strip(text)
+        text.gsub(/\e\[[\d;]*m/, "")
       end
     end
   end

data/lib/asktty/internal/prompt.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module AskTTY
+  module Internal
+    class Prompt
+      def self.ask(...)
+        new(...).ask
+      end
+
+      private_class_method :new
+
+      def initialize(title:, details: nil, &validator)
+        @title = title.to_s
+        @details = details&.to_s
+        @validator = validator
+      end
+
+      def ask
+        @validation_result = nil
+
+        Terminal.open do |session|
+          loop do
+            session.render { |width, height| render(width: width, height: height) }
+            key = session.read_key
+
+            if key == :enter
+              validate if @validation_result.nil?
+              next unless @validation_result == true
+
+              session.render { |width| submitted_render(width: width) }
+              return value
+            end
+
+            handle_key(key)
+          end
+        end
+      end
+
+      private
+
+      attr_reader :value
+
+      def render(width:, height:)
+        content_width = width - 2
+        header = header_lines(width: content_width)
+        footer = footer_lines(width: content_width)
+
+        body_height = height - header.length - footer.length
+        raise AskTTY::Error, "terminal is too short for prompt" if body_height < 1
+
+        body = body_lines(width: content_width, height: body_height)
+        raise AskTTY::Error, "terminal is too short for prompt" if body.length > body_height
+
+        Rendering.frame(header + body + footer)
+      end
+
+      def header_lines(width:)
+        lines = Rendering.wrap(@title, width).map { |line| ANSIStyle.apply(line, :title) }
+        return lines unless @details
+
+        lines + Rendering.wrap(@details, width).map { |line| ANSIStyle.apply(line, :muted) }
+      end
+
+      def help_items
+        [%w[enter submit]]
+      end
+
+      def footer_lines(width:)
+        lines = [""]
+
+        if @validation_result.is_a?(String)
+          lines.concat(Rendering.wrap(@validation_result, width).map { |line| ANSIStyle.apply(line, :error) })
+        end
+
+        lines << Rendering.help_line(help_items, width: width)
+      end
+
+      def submitted_render(width:)
+        prefix = "#{@title}:"
+        summary_value = summary
+        text = summary_value.empty? ? prefix : "#{prefix} #{summary_value}"
+
+        lines = Rendering.wrap(text, width - 2)
+
+        Rendering.frame(lines.map { |line| ANSIStyle.apply(line, :text) })
+      end
+
+      def summary
+        value
+      end
+
+      def validate
+        result = @validator ? @validator.call(value) : true
+
+        @validation_result =
+          if result == true
+            true
+          elsif result.is_a?(String) && !result.empty?
+            result
+          else
+            raise AskTTY::Error, "validator must return true or a non-empty error message"
+          end
+      end
+    end
+  end
+end

data/lib/asktty/internal/rendering.rb

@@ -7,209 +7,123 @@ module AskTTY
     module Rendering
       module_function
 
-      def chop_grapheme(text)
-        graphemes(text.to_s)[0...-1].join
+      def display_text(text)
+        text.gsub(/\r\n?/, "\n").gsub("\t", "  ").gsub(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/) do
+          |character| format("\\x%02X", character.ord)
+        end
       end
 
       def display_width(text)
-        Unicode::DisplayWidth.of(text.to_s.gsub(/\e\[[\d;]*m/, ""), ambiguous: 1)
+        Unicode::DisplayWidth.of(ANSIStyle.strip(text), ambiguous: 1)
       end
 
-      def placeholder_with_cursor(text)
-        first_grapheme, *rest = graphemes(text.to_s)
-        return ANSIStyle.cursor unless first_grapheme
+      def frame(lines)
+        border = ANSIStyle.apply("┃", :muted)
 
-        ANSIStyle.style(first_grapheme, foreground: 8, background: 2) + ANSIStyle.muted(rest.join)
+        lines.map { |line| "#{border} #{line}" }.join("\n")
       end
 
-      def prompt_frame(title:, details:, help_items:, error_message:, width:, gap_before_body: false)
-        content_width = self.content_width(width)
+      def help_line(items, width:)
+        line = +""
+        total_width = 0
 
-        lines = header_lines(title, details, width: content_width)
-        lines << "" if gap_before_body && !lines.empty?
-        lines.concat(Array(yield(content_width)))
-        lines.concat(
-          footer_lines(
-            error_message: error_message, help_line: help_line(help_items, width: content_width), width: content_width
-          )
-        )
+        items.each do |key, description|
+          prefix = total_width.zero? ? "" : " • "
+          segment_width = display_width("#{prefix}#{key} (#{description})")
 
-        frame(lines)
-      end
+          if total_width + segment_width > width
+            ellipsis = line.empty? ? "…" : " …"
 
-      def submitted_frame(title, value, width:)
-        prefix = "#{title}:"
-        summary = value.to_s.empty? ? prefix : "#{prefix} #{value}"
-        lines = wrap(summary, content_width(width))
+            line << ANSIStyle.apply(ellipsis, :text) if total_width + display_width(ellipsis) <= width
+            break
+          end
 
-        frame(lines.map { |line| ANSIStyle.text(line) })
-      end
+          line << ANSIStyle.apply("#{prefix}#{key} ", :text)
+          line << ANSIStyle.apply("(#{description})", :muted)
 
-      def wrap(text, width)
-        split_lines(text.to_s).flat_map { |line| wrap_line(line, width) }
-      end
+          total_width += segment_width
+        end
 
-      def wrap_exact(text, width)
-        split_lines(text.to_s).flat_map { |line| wrap_exact_line(line, width) }
+        line
       end
 
       def prefixed_lines(text, prefix:, width:, style:)
         prefix_width = display_width(prefix)
-        wrapped = wrap(text, [width - prefix_width, 1].max)
+        wrapped = wrap(text, width - prefix_width)
 
         wrapped.each_with_index.map do |line, index|
           current_prefix = index.zero? ? prefix : (" " * prefix_width)
-          current_prefix + style.call(line)
+          current_prefix + ANSIStyle.apply(line, style)
         end
       end
 
-      def header_lines(title, details, width:)
-        lines = wrap(title.to_s, width).map { |line| ANSIStyle.title(line) }
-
-        return lines unless details
-
-        lines + wrap(details.to_s, width).map { |line| ANSIStyle.muted(line) }
-      end
-
-      def footer_lines(error_message:, help_line:, width:)
-        lines = []
-
-        if error_message && !error_message.empty?
-          lines.concat(wrap(error_message, width).map do |line|
-            ANSIStyle.error(line)
-          end)
-        end
-
-        lines << help_line if help_line && !help_line.empty?
-
-        return [] if lines.empty?
+      def split_lines(text)
+        return [""] if text.empty?
 
-        [""] + lines
+        text.split("\n", -1)
       end
 
-      def help_line(items, width:)
-        items = Array(items).map(&:to_s).reject(&:empty?)
-        return "" if items.empty?
+      def take_segment(graphemes, width)
+        last_whitespace_index = nil
+        segment = []
+        segment_width = 0
 
-        line = +""
-        total_width = 0
+        graphemes.each_with_index do |grapheme, index|
+          grapheme_width = display_width(grapheme)
+          raise AskTTY::Error, "terminal is too narrow for prompt content" if grapheme_width > width
 
-        items.each do |item|
-          segment = total_width.zero? ? item : " • #{item}"
-          segment_width = display_width(segment)
+          break if segment_width.positive? && segment_width + grapheme_width > width
 
-          if width.to_i.positive? && total_width + segment_width > width
-            ellipsis = line.empty? ? "…" : " …"
-            line << ellipsis if total_width + display_width(ellipsis) <= width
-            break
-          end
+          last_whitespace_index = index if grapheme.match?(/\s/)
+          segment << grapheme
+          segment_width += grapheme_width
 
-          line << segment
-          total_width += segment_width
+          break if segment_width >= width
         end
 
-        return "" if line.empty?
-
-        line.split(/(\([^)]*\))/).reject(&:empty?).map do |segment|
-          if segment.start_with?("(") && segment.end_with?(")")
-            ANSIStyle.muted(segment)
-          else
-            ANSIStyle.text(segment)
-          end
-        end.join
-      end
-
-      def content_width(width)
-        [width.to_i - 2, 1].max
+        [segment, last_whitespace_index]
       end
 
-      def frame(lines)
-        content_lines = Array(lines).flat_map { |line| split_lines(line.to_s) }
-        border = ANSIStyle.muted("┃")
-
-        content_lines.map { |line| "#{border} #{line}" }.join("\n")
-      end
+      def window(lines, height:, focus:)
+        return lines if lines.length <= height
 
-      def graphemes(text)
-        text.scan(/\X/)
+        start = (focus - (height / 2)).clamp(0, lines.length - height)
+        lines.slice(start, height)
       end
 
-      def split_lines(text)
-        return [""] if text.empty?
+      def wrap(text, width, words: true)
+        raise AskTTY::Error, "terminal is too narrow for prompt content" if width < 1
 
-        text.split("\n", -1)
+        split_lines(display_text(text)).flat_map { |line| wrap_line(line, width, words: words) }
       end
 
-      def wrap_line(line, width)
+      def wrap_line(line, width, words:)
         return [""] if line.empty?
 
         lines = []
-        remaining = graphemes(line)
+        remaining = line.grapheme_clusters
 
         until remaining.empty?
-          if lines.any?
+          if words && lines.any?
             remaining = remaining.drop_while { |grapheme| grapheme.match?(/\s/) }
             break if remaining.empty?
           end
 
           segment, last_whitespace_index = take_segment(remaining, width)
+          count = segment.length
 
-          if segment.length == remaining.length
-            lines << segment.join
-            break
-          end
-
-          if last_whitespace_index&.positive?
+          if words && count < remaining.length && last_whitespace_index&.positive?
+            count = last_whitespace_index + 1
             lines << segment[0...last_whitespace_index].join.rstrip
-            remaining = remaining[(last_whitespace_index + 1)..] || []
-            remaining = remaining.drop_while { |grapheme| grapheme.match?(/\s/) }
           else
             lines << segment.join
-            remaining = remaining[segment.length..] || []
           end
-        end
-
-        lines
-      end
 
-      def wrap_exact_line(line, width)
-        return [""] if line.empty?
-
-        lines = []
-        remaining = graphemes(line)
-
-        until remaining.empty?
-          segment, = take_segment(remaining, width)
-          lines << segment.join
-          remaining = remaining[segment.length..] || []
+          remaining = remaining.drop(count)
         end
 
         lines
       end
-
-      def take_segment(graphemes, width)
-        segment = []
-        segment_width = 0
-        last_whitespace_index = nil
-
-        graphemes.each_with_index do |grapheme, index|
-          grapheme_width = display_width(grapheme)
-
-          if segment_width.zero? && grapheme_width > width
-            return [[grapheme], grapheme.match?(/\s/) ? 0 : nil]
-          end
-
-          break if segment_width.positive? && segment_width + grapheme_width > width
-
-          segment << grapheme
-          segment_width += grapheme_width
-          last_whitespace_index = index if grapheme.match?(/\s/)
-
-          break if segment_width >= width
-        end
-
-        [segment, last_whitespace_index]
-      end
     end
   end
 end

data/lib/asktty/internal/terminal.rb

@@ -1,16 +1,16 @@
 # frozen_string_literal: true
 
 require "io/console"
+require "io/wait"
 
 module AskTTY
   module Internal
     class Terminal
-      ESCAPE_START_TIMEOUT = 0.1
-      ESCAPE_CONTINUATION_TIMEOUT = 0.01
+      Paste = Data.define(:text)
 
-      private_constant :ESCAPE_START_TIMEOUT, :ESCAPE_CONTINUATION_TIMEOUT
+      ESCAPE_TIMEOUT = 0.1
 
-      attr_reader :width
+      private_constant :ESCAPE_TIMEOUT
 
       def self.open(&)
         raise AskTTY::Error, "interactive prompts require a TTY input and output" unless $stdin.tty? && $stdout.tty?
@@ -21,32 +21,33 @@ module AskTTY
       def initialize(input:, output:)
         @input = input
         @output = output
-        @line_count = 0
-        @width = output.winsize[1]
-        @width = 80 if @width.nil? || @width <= 0
-      rescue StandardError
-        @width = 80
+        @frame = ""
+        @height, @width = dimensions
       end
 
       def open
-        @output.print "\e[?25l"
+        @output.print "\e[?25l\e[?2004h"
         @output.flush
 
         @input.raw do
           yield self
         end
       ensure
-        @line_count = 0
-        @output.print "\e[0m\r\n\e[?25h"
+        @frame = ""
+        @output.print "\e[?2004l\e[0m\r\n\e[?25h"
         @output.flush
       end
 
       def read_key
-        character = @input.getch
+        loop do
+          return :resize if dimensions != [@height, @width]
+
+          break if @input.wait_readable(0.1)
+        end
+
+        character = read_character
 
         case character
-        when "\u0003"
-          raise Interrupt
         when "\r"
           :enter
         when "\n"
@@ -54,51 +55,29 @@ module AskTTY
         when "\u007F", "\b"
           :backspace
         when "\e"
-          decode_escape_sequence(read_escape_sequence)
+          sequence = read_escape_sequence
+          sequence == "[200~" ? read_paste : decode_escape_sequence(sequence)
         else
           character
         end
       end
 
-      def render(text)
-        text = text.to_s
+      def render
+        @height, @width = dimensions
 
-        if @line_count > 1
-          @output.print "\e[#{@line_count - 1}F"
-        else
-          @output.print "\r"
-        end
+        text = yield(@width, @height)
+        rows = occupied_rows
 
+        @output.print rows > 1 ? "\e[#{rows - 1}F" : "\r"
         @output.print "\e[J"
-        @output.print normalize_output(text)
+        @output.print text.gsub("\n", "\r\n")
         @output.flush
 
-        @line_count = [text.split("\n", -1).length, 1].max
+        @frame = text
       end
 
       private
 
-      def normalize_output(text)
-        text.gsub("\n", "\r\n")
-      end
-
-      def read_escape_sequence
-        sequence = +""
-        timeout = ESCAPE_START_TIMEOUT
-
-        while @input.wait_readable(timeout)
-          chunk = @input.read_nonblock(1, exception: false)
-          break if chunk == :wait_readable || chunk.nil?
-
-          sequence << chunk
-          break if chunk.match?(/[A-Za-z~]/)
-
-          timeout = ESCAPE_CONTINUATION_TIMEOUT
-        end
-
-        sequence
-      end
-
       def decode_escape_sequence(sequence)
         case sequence
         when "[A", "OA"
@@ -115,6 +94,70 @@ module AskTTY
           :escape
         end
       end
+
+      def dimensions
+        rows, columns = @output.winsize
+
+        [rows.to_i.positive? ? rows : 24, columns.to_i.positive? ? columns : 80]
+      rescue IOError, SystemCallError
+        [24, 80]
+      end
+
+      def occupied_rows
+        Rendering.split_lines(@frame).sum do |line|
+          column = 0
+          rows = 1
+
+          ANSIStyle.strip(line).each_grapheme_cluster do |grapheme|
+            width = Rendering.display_width(grapheme)
+
+            if column.positive? && column + width > @width
+              column = 0
+              rows += 1
+            end
+
+            column += width
+          end
+
+          rows
+        end
+      end
+
+      def read_character
+        character = @input.getch
+        raise AskTTY::Error, "terminal input closed" unless character
+        raise Interrupt if character == "\u0003"
+
+        character
+      end
+
+      def read_escape_sequence
+        sequence = +""
+
+        while @input.wait_readable(ESCAPE_TIMEOUT)
+          chunk = @input.read_nonblock(1, exception: false)
+          break if chunk == :wait_readable || chunk.nil?
+
+          raise Interrupt if chunk == "\u0003"
+
+          sequence << chunk
+
+          if sequence.length == 1
+            break unless ["[", "O"].include?(chunk)
+          elsif chunk.match?(/[@-~]/)
+            break
+          end
+        end
+
+        sequence
+      end
+
+      def read_paste
+        text = +""
+        text << read_character until text.end_with?("\e[201~")
+
+        Paste.new(text.delete_suffix("\e[201~"))
+      end
     end
   end
 end