asktty 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4918843985d1b7a0204a197a2e8499ca7493e171bc4b16307407bab000572c15
+  data.tar.gz: af5db2494b82ba83bddd0813d40a86dd50833276ba6a00e8df3d2b9b79d1a5e4
+SHA512:
+  metadata.gz: 0fa70b12b633518b2ab3aac623dada69b67e337401c0d21d466126b0c6a24927921323941357ac81c259e16bc97c2eb75a9a03323af73aa4e0a17f10911bf300
+  data.tar.gz: 6fba726118b1e937822797c90b84cf840e69c70c77c1f0cc6a7ce772cc063e4ff242559157d031cae16592ddf1b150bafa5a3f35c8bf0d3348677591e6da4e94

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Vlad Suchy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,107 @@
+# AskTTY
+
+> Note: AskTTY is still under development and has not been released to RubyGems yet.
+
+A Ruby gem for interactive terminal prompts.
+
+## Installation
+
+Install it globaly:
+
+```sh
+gem install asktty
+```
+
+or, add it to your application gemfile:
+
+```sh
+bundle add asktty
+```
+
+## Usage
+
+```ruby
+require "asktty"
+```
+
+### Input Prompt
+
+```ruby
+name = AskTTY::InputPrompt.ask(
+  title: "Name",
+  details: "Enter the name you want displayed on your badge.",
+  placeholder: "Vlad"
+)
+```
+
+### Text Prompt
+
+```ruby
+notes = AskTTY::TextPrompt.ask(
+  title: "Ruby Project",
+  placeholder: "AskTTY\nTerminal prompts for Ruby"
+)
+```
+
+### Select Prompt
+
+```ruby
+drink = AskTTY::SelectPrompt.ask(
+  title: "Experience Level",
+  options: [
+    { label: "Beginner", value: :beginner },
+    { label: "Intermediate", value: :intermediate },
+    { label: "Advanced", value: :advanced }
+  ],
+  value: :intermediate
+)
+```
+
+### MultiSelect Prompt
+
+```ruby
+toppings = AskTTY::MultiSelectPrompt.ask(
+  title: "Topics",
+  details: "Select all topics you are interested in.",
+  options: [
+    { label: "Rails", value: :rails },
+    { label: "Metaprogramming", value: :metaprogramming },
+    { label: "API development", value: :api_development },
+    { label: "Background jobs", value: :background_jobs },
+    { label: "Testing", value: :testing }
+  ],
+  values: [:metaprogramming]
+)
+```
+
+### Confirm Prompt
+
+```ruby
+confirmed = AskTTY::ConfirmPrompt.ask(
+  title: "Confirmation",
+  details: "Confirm that you plan to attend the event.",
+  value: true
+)
+```
+
+### Validation
+
+Pass a block that returns `true` when the current value is valid, or an error message when it is not:
+
+```ruby
+name = AskTTY::InputPrompt.ask(title: "Name") do |value|
+  value.length >= 3 || "Name must be at least 3 characters"
+end
+```
+
+## Examples
+
+Run the interactive example from the project root:
+
+```sh
+ruby examples/all_prompts.rb
+```
+
+## Credit
+
+The prompt UI in AskTTY is based on [huh?](https://github.com/charmbracelet/huh).

data/lib/asktty/internal/ansi_style.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+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
+
+      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
+
+      def cursor(text = " ")
+        style(text, foreground: 7, background: 2)
+      end
+
+      def error(text)
+        style(text, foreground: 9)
+      end
+    end
+  end
+end

data/lib/asktty/internal/options.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module AskTTY
+  module Internal
+    module Options
+      Option = Struct.new(:label, :value)
+
+      module_function
+
+      def normalize(options)
+        raise AskTTY::Error, "options must not be empty" if options.nil? || options.empty?
+
+        options.map do |option|
+          next option if option.is_a?(Option)
+
+          raise AskTTY::Error, "options must be hashes with label and value" unless option.is_a?(Hash)
+
+          label = option[:label] || option["label"]
+          has_value = option.key?(:value) || option.key?("value")
+          value = option[:value] if option.key?(:value)
+          value = option["value"] if option.key?("value")
+
+          raise AskTTY::Error, "options must include label and value" unless label && has_value
+
+          Option.new(label.to_s, value)
+        end
+      end
+
+      def values(options)
+        options.map(&:value)
+      end
+    end
+  end
+end

data/lib/asktty/internal/rendering.rb

@@ -0,0 +1,214 @@
+# frozen_string_literal: true
+
+require "unicode/display_width"
+
+module AskTTY
+  module Internal
+    module Rendering
+      module_function
+
+      def chop_grapheme(text)
+        graphemes(text.to_s)[0...-1].join
+      end
+
+      def display_width(text)
+        Unicode::DisplayWidth.of(text.to_s.gsub(/\e\[[\d;]*m/, ""), ambiguous: 1)
+      end
+
+      def placeholder_with_cursor(text)
+        first_grapheme, *rest = graphemes(text.to_s)
+        return ANSIStyle.cursor unless first_grapheme
+
+        ANSIStyle.style(first_grapheme, foreground: 8, background: 2) + ANSIStyle.muted(rest.join)
+      end
+
+      def prompt_frame(title:, details:, help_items:, error_message:, width:, gap_before_body: false)
+        content_width = self.content_width(width)
+
+        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
+          )
+        )
+
+        frame(lines)
+      end
+
+      def submitted_frame(title, value, width:)
+        prefix = "#{title}:"
+        summary = value.to_s.empty? ? prefix : "#{prefix} #{value}"
+        lines = wrap(summary, content_width(width))
+
+        frame(style_submitted_lines(lines, title_length: graphemes(prefix).length))
+      end
+
+      def wrap(text, width)
+        split_lines(text.to_s).flat_map { |line| wrap_line(line, width) }
+      end
+
+      def wrap_exact(text, width)
+        split_lines(text.to_s).flat_map { |line| wrap_exact_line(line, width) }
+      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?
+
+        [""] + lines
+      end
+
+      def help_line(items, width:)
+        items = Array(items).map(&:to_s).reject(&:empty?)
+        return "" if items.empty?
+
+        line = +""
+        total_width = 0
+
+        items.each do |item|
+          segment = total_width.zero? ? item : " • #{item}"
+          segment_width = display_width(segment)
+
+          if width.to_i.positive? && total_width + segment_width > width
+            line << " …" if total_width + display_width(" …") <= width
+            break
+          end
+
+          line << segment
+          total_width += segment_width
+        end
+
+        return "" if line.empty?
+
+        ANSIStyle.muted(line)
+      end
+
+      def content_width(width)
+        [width.to_i - 2, 1].max
+      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 graphemes(text)
+        text.scan(/\X/)
+      end
+
+      def split_lines(text)
+        return [""] if text.empty?
+
+        text.split("\n", -1)
+      end
+
+      def style_submitted_lines(lines, title_length:)
+        remaining_title_length = title_length
+
+        lines.map do |line|
+          line_graphemes = graphemes(line)
+
+          if remaining_title_length >= line_graphemes.length
+            remaining_title_length -= line_graphemes.length
+            ANSIStyle.title(line)
+          elsif remaining_title_length.positive?
+            title_text = line_graphemes[0, remaining_title_length].join
+            value_text = line_graphemes[remaining_title_length..].to_a.join
+            remaining_title_length = 0
+
+            ANSIStyle.title(title_text) + ANSIStyle.text(value_text)
+          else
+            ANSIStyle.text(line)
+          end
+        end
+      end
+
+      def wrap_line(line, width)
+        return [""] if line.empty?
+
+        lines = []
+        remaining = graphemes(line)
+
+        until remaining.empty?
+          segment, last_whitespace_index = take_segment(remaining, width)
+
+          if segment.length == remaining.length
+            lines << segment.join
+            break
+          end
+
+          if last_whitespace_index&.positive?
+            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..] || []
+        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

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+require "io/console"
+
+module AskTTY
+  module Internal
+    class Terminal
+      attr_reader :width
+
+      def self.open(&)
+        raise AskTTY::Error, "interactive prompts require a TTY input and output" unless $stdin.tty? && $stdout.tty?
+
+        new(input: $stdin, output: $stdout).open(&)
+      end
+
+      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
+      end
+
+      def open
+        @output.print "\e[?25l"
+        @output.flush
+
+        @input.raw do
+          yield self
+        end
+      ensure
+        @line_count = 0
+        @output.print "\e[0m\r\n\e[?25h"
+        @output.flush
+      end
+
+      def read_key
+        character = @input.getch
+
+        case character
+        when "\u0003"
+          raise Interrupt
+        when "\r"
+          :enter
+        when "\n"
+          :ctrl_j
+        when "\u007F", "\b"
+          :backspace
+        when "\e"
+          decode_escape_sequence(read_escape_sequence)
+        else
+          character
+        end
+      end
+
+      def render(text)
+        text = text.to_s
+
+        if @line_count > 1
+          @output.print "\e[#{@line_count - 1}F"
+        else
+          @output.print "\r"
+        end
+
+        @output.print "\e[J"
+        @output.print normalize_output(text)
+        @output.flush
+
+        @line_count = [text.split("\n", -1).length, 1].max
+      end
+
+      private
+
+      def normalize_output(text)
+        text.gsub("\n", "\r\n")
+      end
+
+      def read_escape_sequence
+        sequence = +""
+
+        while @input.wait_readable(0.01)
+          chunk = @input.read_nonblock(1, exception: false)
+          break if chunk == :wait_readable || chunk.nil?
+
+          sequence << chunk
+          break if chunk.match?(/[A-Za-z~]/)
+        end
+
+        sequence
+      end
+
+      def decode_escape_sequence(sequence)
+        case sequence
+        when "[A", "OA"
+          :up
+        when "[B", "OB"
+          :down
+        when "[D", "OD"
+          :left
+        when "[C", "OC"
+          :right
+        when "[13;2u", "[13;2~", "[27;2;13~"
+          :shift_enter
+        else
+          :escape
+        end
+      end
+    end
+  end
+end

data/lib/asktty/internal/text_input_prompt.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module AskTTY
+  module Internal
+    class TextInputPrompt
+      def initialize(title:, details: nil, placeholder: nil, value: nil, validator: nil, multiline: false)
+        @title = title.to_s
+        @details = details&.to_s
+        @placeholder = placeholder&.to_s
+        @value = value.to_s
+        @validator = validator
+        @multiline = multiline
+      end
+
+      def ask
+        value = @value.dup
+        validation_active = false
+
+        Terminal.open do |session|
+          loop do
+            session.render(
+              render(
+                value,
+                width: session.width,
+                show_cursor: true,
+                error_message: validation_message(value, validation_active)
+              )
+            )
+
+            key = session.read_key
+
+            case key
+            when :enter
+              validation_active = true
+              next if validation_message(value, validation_active)
+
+              session.render(submitted_render(value, width: session.width))
+              return value
+            when :shift_enter, :ctrl_j
+              next unless @multiline
+
+              value << "\n"
+              validation_active = true
+            when :backspace
+              updated_value = Rendering.chop_grapheme(value)
+              validation_active ||= updated_value != value
+              value = updated_value
+            when String
+              next unless printable?(key)
+
+              value << key
+              validation_active = true
+            end
+          end
+        end
+      end
+
+      private
+
+      def render(value, width:, show_cursor:, error_message: nil)
+        Rendering.prompt_frame(
+          title: @title, details: @details, help_items: help_items, error_message: error_message, width: width
+        ) do |content_width|
+          body_lines(value, content_width: content_width, show_cursor: show_cursor)
+        end
+      end
+
+      def submitted_render(value, width:)
+        Rendering.submitted_frame(@title, summary_value(value), width: width)
+      end
+
+      def body_lines(value, content_width:, show_cursor:)
+        return placeholder_lines(content_width) if @placeholder && value.empty? && show_cursor
+
+        render_segments(value_lines(value), content_width: content_width, show_cursor: show_cursor)
+      end
+
+      def placeholder_lines(content_width)
+        render_segments(
+          @placeholder.to_s.split("\n", -1),
+          content_width: content_width,
+          show_cursor: false,
+          first_style: method(:placeholder_first_line),
+          style: ANSIStyle.method(:muted)
+        )
+      end
+
+      def value_lines(value)
+        return [value] unless @multiline
+
+        value.split("\n", -1)
+      end
+
+      def help_items
+        return ["enter (submit)"] unless @multiline
+
+        ["enter (submit)", "shift+enter/ctrl+j (new line)"]
+      end
+
+      def placeholder_first_line(text)
+        Rendering.placeholder_with_cursor(text)
+      end
+
+      def printable?(character)
+        character.length == 1 && character >= " "
+      end
+
+      def render_segments(
+        segments, content_width:, show_cursor:, first_style: ANSIStyle.method(:text), style: first_style
+      )
+        segments = [""] if segments.empty?
+        wrap_width = [content_width - 2, 1].max
+        last_index = segments.length - 1
+
+        segments.each_with_index.flat_map do |segment, segment_index|
+          wrapped_segments = Rendering.wrap_exact(segment, wrap_width)
+          wrapped_segments = [""] if wrapped_segments.empty?
+
+          if show_cursor && segment_index == last_index && Rendering.display_width(wrapped_segments.last) >= wrap_width
+            wrapped_segments << ""
+          end
+
+          wrapped_segments.each_with_index.map do |part, wrapped_index|
+            prefix = segment_index.zero? && wrapped_index.zero? ? ANSIStyle.prompt("> ") : "  "
+            current_style = segment_index.zero? && wrapped_index.zero? ? first_style : style
+            line = prefix + current_style.call(part)
+
+            if show_cursor && segment_index == last_index && wrapped_index == wrapped_segments.length - 1
+              line << ANSIStyle.cursor
+            end
+
+            line
+          end
+        end
+      end
+
+      def summary_value(value)
+        return value unless @multiline
+
+        value.tr("\n", " ")
+      end
+
+      def validation_message(value, validation_active)
+        Validation.message_for(value, @validator, active: validation_active)
+      end
+    end
+  end
+end

data/lib/asktty/internal/validation.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module AskTTY
+  module Internal
+    module Validation
+      module_function
+
+      def message_for(value, validator, active:)
+        return nil unless active && validator
+
+        result = validator.call(value)
+        return nil if result == true
+        return result if result.is_a?(String)
+
+        raise AskTTY::Error, "validator must return true or an error message"
+      end
+    end
+  end
+end

data/lib/asktty/prompts/confirm_prompt.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module AskTTY
+  class ConfirmPrompt
+    def self.ask(title:, details: nil, value: false, &validator)
+      new(title: title, details: details, value: value, validator: validator).ask
+    end
+
+    def initialize(title:, details: nil, value: false, validator: nil)
+      @title = title.to_s
+      @details = details&.to_s
+
+      raise AskTTY::Error, "value must be true or false" unless [true, false].include?(value)
+
+      @value = value
+      @validator = validator
+    end
+
+    def ask
+      validation_active = false
+
+      Internal::Terminal.open do |session|
+        loop do
+          session.render(render(width: session.width, error_message: validation_message(validation_active)))
+
+          case session.read_key
+          when :enter
+            validation_active = true
+            next if validation_message(validation_active)
+
+            session.render(submitted_render(width: session.width))
+            return @value
+          when :left, "h"
+            previous_value = @value
+            @value = true
+            validation_active ||= @value != previous_value
+          when :right, "l"
+            previous_value = @value
+            @value = false
+            validation_active ||= @value != previous_value
+          end
+        end
+      end
+    end
+
+    private
+
+    def render(width:, error_message: nil)
+      Internal::Rendering.prompt_frame(
+        title: @title,
+        details: @details,
+        help_items: help_items,
+        error_message: error_message,
+        width: width,
+        gap_before_body: true
+      ) do |content_width|
+        button_lines(content_width)
+      end
+    end
+
+    def submitted_render(width:)
+      Internal::Rendering.submitted_frame(@title, @value ? "Yes" : "No", width: width)
+    end
+
+    def button_lines(content_width)
+      yes_button = @value ? Internal::ANSIStyle.focused_button("Yes") : Internal::ANSIStyle.blurred_button("Yes")
+      no_button = @value ? Internal::ANSIStyle.blurred_button("No") : Internal::ANSIStyle.focused_button("No")
+
+      row = "#{yes_button} #{no_button}"
+
+      return [row] if Internal::Rendering.display_width(row) <= content_width
+
+      button_width = [
+        Internal::Rendering.display_width(yes_button),
+        Internal::Rendering.display_width(no_button)
+      ].max
+
+      raise AskTTY::Error, "terminal is too narrow for confirmation prompt" if button_width > content_width
+
+      [yes_button, no_button]
+    end
+
+    def help_items
+      ["enter (submit)", "left/right (select option)"]
+    end
+
+    def validation_message(validation_active)
+      Internal::Validation.message_for(@value, @validator, active: validation_active)
+    end
+  end
+end

data/lib/asktty/prompts/input_prompt.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module AskTTY
+  class InputPrompt
+    def self.ask(title:, details: nil, placeholder: nil, value: nil, &validator)
+      new(title: title, details: details, placeholder: placeholder, value: value, validator: validator).ask
+    end
+
+    def initialize(title:, details: nil, placeholder: nil, value: nil, validator: nil)
+      @prompt = Internal::TextInputPrompt.new(
+        title: title, details: details, placeholder: placeholder, value: value, validator: validator, multiline: false
+      )
+    end
+
+    def ask
+      @prompt.ask
+    end
+  end
+end

data/lib/asktty/prompts/multi_select_prompt.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module AskTTY
+  class MultiSelectPrompt
+    def self.ask(title:, options:, details: nil, values: nil, &validator)
+      new(title: title, details: details, options: options, values: values, validator: validator).ask
+    end
+
+    def initialize(title:, options:, details: nil, values: nil, validator: nil)
+      @title = title.to_s
+      @details = details&.to_s
+      @options = Internal::Options.normalize(options)
+      @values = Array(values).uniq
+      @validator = validator
+
+      option_values = Internal::Options.values(@options)
+
+      unknown_values = @values - option_values
+      raise AskTTY::Error, "values contain unknown option values" unless unknown_values.empty?
+
+      @index = first_selected_index || 0
+    end
+
+    def ask
+      validation_active = false
+
+      Internal::Terminal.open do |session|
+        loop do
+          session.render(render(width: session.width, error_message: validation_message(validation_active)))
+
+          case session.read_key
+          when :enter
+            validation_active = true
+            next if validation_message(validation_active)
+
+            session.render(submitted_render(width: session.width))
+            return selected_results
+          when :up, "k"
+            move(-1)
+          when :down, "j"
+            move(1)
+          when " "
+            previous_results = selected_results
+            toggle_current
+            validation_active ||= selected_results != previous_results
+          end
+        end
+      end
+    end
+
+    private
+
+    def render(width:, error_message: nil)
+      Internal::Rendering.prompt_frame(
+        title: @title, details: @details, help_items: help_items, error_message: error_message, width: width
+      ) do |content_width|
+        option_lines(content_width)
+      end
+    end
+
+    def submitted_render(width:)
+      labels = selected_options.map(&:label).join(", ")
+
+      Internal::Rendering.submitted_frame(@title, labels, width: width)
+    end
+
+    def option_lines(content_width)
+      @options.each_with_index.flat_map do |option, index|
+        cursor = index == @index ? Internal::ANSIStyle.prompt("> ") : "  "
+        selected = @values.include?(option.value)
+        prefix = selected ? Internal::ANSIStyle.selected("[•] ") : Internal::ANSIStyle.text("[ ] ")
+        style = selected ? Internal::ANSIStyle.method(:selected) : Internal::ANSIStyle.method(:text)
+
+        wrap_option(option.label, cursor: cursor, prefix: prefix, width: content_width, &style)
+      end
+    end
+
+    def first_selected_index
+      @options.index { |option| @values.include?(option.value) }
+    end
+
+    def help_items
+      ["enter (submit)", "up/down (select item)", "space (toggle item)"]
+    end
+
+    def move(offset)
+      @index = (@index + offset) % @options.length
+    end
+
+    def selected_options
+      @options.select { |option| @values.include?(option.value) }
+    end
+
+    def selected_results
+      selected_options.map(&:value)
+    end
+
+    def toggle_current
+      value = @options[@index].value
+
+      if @values.include?(value)
+        @values.delete(value)
+      else
+        @values << value
+      end
+    end
+
+    def validation_message(validation_active)
+      Internal::Validation.message_for(selected_results, @validator, active: validation_active)
+    end
+
+    def wrap_option(label, cursor:, prefix:, width:, &style)
+      prefix_width = Internal::Rendering.display_width(cursor + prefix)
+      wrapped = Internal::Rendering.wrap(label, [width - prefix_width, 1].max)
+
+      wrapped.each_with_index.map do |line, index|
+        current_prefix = index.zero? ? cursor + prefix : (" " * prefix_width)
+        current_prefix + style.call(line)
+      end
+    end
+  end
+end

data/lib/asktty/prompts/select_prompt.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module AskTTY
+  class SelectPrompt
+    UNSET = Object.new
+
+    def self.ask(title:, options:, details: nil, value: UNSET, &validator)
+      new(title: title, details: details, options: options, value: value, validator: validator).ask
+    end
+
+    def initialize(title:, options:, details: nil, value: UNSET, validator: nil)
+      @title = title.to_s
+      @details = details&.to_s
+      @options = Internal::Options.normalize(options)
+      @index = index_for(value)
+      @validator = validator
+    end
+
+    def ask
+      validation_active = false
+
+      Internal::Terminal.open do |session|
+        loop do
+          session.render(render(width: session.width, error_message: validation_message(validation_active)))
+
+          case session.read_key
+          when :enter
+            validation_active = true
+            next if validation_message(validation_active)
+
+            session.render(submitted_render(width: session.width))
+            return selected_option.value
+          when :up, "k"
+            previous_value = selected_option.value
+            move(-1)
+            validation_active ||= selected_option.value != previous_value
+          when :down, "j"
+            previous_value = selected_option.value
+            move(1)
+            validation_active ||= selected_option.value != previous_value
+          end
+        end
+      end
+    end
+
+    private
+
+    def render(width:, error_message: nil)
+      Internal::Rendering.prompt_frame(
+        title: @title, details: @details, help_items: help_items, error_message: error_message, width: width
+      ) do |content_width|
+        option_lines(content_width)
+      end
+    end
+
+    def submitted_render(width:)
+      Internal::Rendering.submitted_frame(@title, selected_option.label, width: width)
+    end
+
+    def option_lines(content_width)
+      @options.each_with_index.flat_map do |option, index|
+        prefix = index == @index ? Internal::ANSIStyle.prompt("> ") : "  "
+        style = index == @index ? Internal::ANSIStyle.method(:selected) : Internal::ANSIStyle.method(:text)
+
+        wrap_option(option.label, prefix: prefix, width: content_width, &style)
+      end
+    end
+
+    def help_items
+      ["enter (submit)", "up/down (select item)"]
+    end
+
+    def index_for(value)
+      return 0 if value.equal?(UNSET)
+
+      @options.index { |option| option.value == value } ||
+        raise(AskTTY::Error, "value is not a valid option value")
+    end
+
+    def move(offset)
+      @index = (@index + offset) % @options.length
+    end
+
+    def selected_option
+      @options[@index]
+    end
+
+    def validation_message(validation_active)
+      Internal::Validation.message_for(selected_option.value, @validator, active: validation_active)
+    end
+
+    def wrap_option(label, prefix:, width:, &style)
+      wrapped = Internal::Rendering.wrap(label, [width - 2, 1].max)
+
+      wrapped.each_with_index.map do |line, index|
+        current_prefix = index.zero? ? prefix : "  "
+        current_prefix + style.call(line)
+      end
+    end
+  end
+end

data/lib/asktty/prompts/text_prompt.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module AskTTY
+  class TextPrompt
+    def self.ask(title:, details: nil, placeholder: nil, value: nil, &validator)
+      new(title: title, details: details, placeholder: placeholder, value: value, validator: validator).ask
+    end
+
+    def initialize(title:, details: nil, placeholder: nil, value: nil, validator: nil)
+      @prompt = Internal::TextInputPrompt.new(
+        title: title, details: details, placeholder: placeholder, value: value, validator: validator, multiline: true
+      )
+    end
+
+    def ask
+      @prompt.ask
+    end
+  end
+end

data/lib/asktty/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module AskTTY
+  VERSION = "1.0.0"
+end

data/lib/asktty.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative "asktty/version"
+require_relative "asktty/internal/ansi_style"
+require_relative "asktty/internal/options"
+require_relative "asktty/internal/rendering"
+require_relative "asktty/internal/terminal"
+require_relative "asktty/internal/validation"
+require_relative "asktty/internal/text_input_prompt"
+require_relative "asktty/prompts/input_prompt"
+require_relative "asktty/prompts/text_prompt"
+require_relative "asktty/prompts/select_prompt"
+require_relative "asktty/prompts/multi_select_prompt"
+require_relative "asktty/prompts/confirm_prompt"
+
+module AskTTY
+  class Error < StandardError; end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification
+name: asktty
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Vlad Suchy
+bindir: bin
+cert_chain: []
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: unicode-display_width
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+description: |
+  AskTTY is a Ruby library for interactive terminal prompts in CLI applications and scripts.
+  It provides input, text, select, multi-select and confirm prompts
+  through a small, direct API with a polished terminal UI.
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- lib/asktty.rb
+- lib/asktty/internal/ansi_style.rb
+- lib/asktty/internal/options.rb
+- lib/asktty/internal/rendering.rb
+- lib/asktty/internal/terminal.rb
+- lib/asktty/internal/text_input_prompt.rb
+- lib/asktty/internal/validation.rb
+- lib/asktty/prompts/confirm_prompt.rb
+- lib/asktty/prompts/input_prompt.rb
+- lib/asktty/prompts/multi_select_prompt.rb
+- lib/asktty/prompts/select_prompt.rb
+- lib/asktty/prompts/text_prompt.rb
+- lib/asktty/version.rb
+homepage: https://github.com/vsuchy/asktty
+licenses:
+- MIT
+metadata:
+  rubygems_mfa_required: 'true'
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 3.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 4.0.10
+specification_version: 4
+summary: Terminal prompts for Ruby.
+test_files: []