tty2-prompt 0.23.1.3

data/lib/tty2/prompt/question.rb

@@ -0,0 +1,391 @@
+# frozen_string_literal: true
+
+require_relative "converters"
+require_relative "evaluator"
+require_relative "question/modifier"
+require_relative "question/validation"
+require_relative "question/checks"
+require_relative "utils"
+
+module TTY2
+  # A class responsible for shell prompt interactions.
+  class Prompt
+    # A class responsible for gathering user input
+    #
+    # @api public
+    class Question
+      include Checks
+
+      UndefinedSetting = Class.new do
+        def to_s
+          "undefined"
+        end
+        alias_method :inspect, :to_s
+      end
+
+      # Store question message
+      # @api public
+      attr_reader :message
+
+      attr_reader :modifier
+
+      attr_reader :validation
+
+      # Initialize a Question
+      #
+      # @api public
+      def initialize(prompt, **options)
+        # Option deprecation
+        if options[:validation]
+          warn "[DEPRECATION] The `:validation` option is deprecated. Use `:validate` instead."
+          options[:validate] = options[:validation]
+        end
+
+        @prompt       = prompt
+        @prefix       = options.fetch(:prefix) { @prompt.prefix }
+        @default      = options.fetch(:default) { UndefinedSetting }
+        @required     = options.fetch(:required) { false }
+        @echo         = options.fetch(:echo) { true }
+        @in           = options.fetch(:in) { UndefinedSetting }
+        @modifier     = options.fetch(:modifier) { [] }
+        @validation   = options.fetch(:validate) { UndefinedSetting }
+        @convert      = options.fetch(:convert) { UndefinedSetting }
+        @active_color = options.fetch(:active_color) { @prompt.active_color }
+        @help_color   = options.fetch(:help_color) { @prompt.help_color }
+        @error_color  = options.fetch(:error_color) { :red }
+        @value        = options.fetch(:value) { UndefinedSetting }
+        @quiet        = options.fetch(:quiet) { @prompt.quiet }
+        @messages     = Utils.deep_copy(options.fetch(:messages) { {} })
+        @done         = false
+        @first_render = true
+        @input        = nil
+
+        @evaluator = Evaluator.new(self)
+
+        @evaluator << CheckRequired
+        @evaluator << CheckDefault
+        @evaluator << CheckRange
+        @evaluator << CheckValidation
+        @evaluator << CheckModifier
+        @evaluator << CheckConversion
+      end
+
+      # Stores all the error messages displayed to user
+      # The currently supported messages are:
+      #  * :range?
+      #  * :required?
+      #  * :valid?
+      attr_reader :messages
+
+      # Retrieve message based on the key
+      #
+      # @param [Symbol] name
+      #   the name of message key
+      #
+      # @param [Hash] tokens
+      #   the tokens to evaluate
+      #
+      # @return [Array[String]]
+      #
+      # @api private
+      def message_for(name, tokens = nil)
+        template = @messages[name]
+        if template && !template.match(/\%\{/).nil?
+          [template % tokens]
+        else
+          [template || ""]
+        end
+      end
+
+      # Call the question
+      #
+      # @param [String] message
+      #
+      # @return [self]
+      #
+      # @api public
+      def call(message = "", &block)
+        @message = message
+        block.call(self) if block
+        @prompt.subscribe(self) do
+          render
+        end
+      end
+
+      # Read answer and convert to type
+      #
+      # @api private
+      def render
+        @errors = []
+        until @done
+          result = process_input(render_question)
+          if result.failure?
+            @errors = result.errors
+            @prompt.print(render_error(result.errors))
+          else
+            @done = true
+          end
+          question    = render_question
+          input_line  = question + result.value.to_s
+          total_lines = @prompt.count_screen_lines(input_line)
+          @prompt.print(refresh(question.lines.count, total_lines))
+        end
+        @prompt.print(render_question) unless @quiet
+        result.value
+      end
+
+      # Render question
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_question
+        header = []
+        if !Utils.blank?(@prefix) || !Utils.blank?(message)
+          header << "#{@prefix}#{message} "
+        end
+        if !echo?
+          header
+        elsif @done
+          header << @prompt.decorate(@input.to_s, @active_color)
+        elsif default? && !Utils.blank?(@default)
+          header << @prompt.decorate("(#{default})", @help_color) + " "
+        end
+        header << "\n" if @done
+        header.join
+      end
+
+      # Decide how to handle input from user
+      #
+      # @api private
+      def process_input(question)
+        @input = read_input(question)
+        if Utils.blank?(@input)
+          @input = default? ? default : nil
+        end
+        @evaluator.(@input)
+      end
+
+      # Process input
+      #
+      # @api private
+      def read_input(question)
+        options = { echo: echo }
+        if value? && @first_render
+          options[:value] = @value
+          @first_render = false
+        end
+        @prompt.read_line(question, **options).chomp
+      end
+
+      # Handle error condition
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_error(errors)
+        errors.reduce([]) do |acc, err|
+          acc << @prompt.decorate(">>", :red) + " " + err
+          acc
+        end.join("\n")
+      end
+
+      # Determine area of the screen to clear
+      #
+      # @param [Integer] lines
+      #   number of lines to clear
+      #
+      # @return [String]
+      #
+      # @api private
+      def refresh(lines, lines_to_clear)
+        output = []
+        if @done
+          if @errors.count.zero?
+            output << @prompt.cursor.up(lines)
+          else
+            lines += @errors.count
+            lines_to_clear += @errors.count
+          end
+        else
+          output << @prompt.cursor.up(lines)
+        end
+        output.join + @prompt.clear_lines(lines_to_clear)
+      end
+
+      # Convert value to expected type
+      #
+      # @param [Object] value
+      #
+      # @api private
+      def convert_result(value)
+        if convert? && !Utils.blank?(value)
+          case @convert
+          when Proc
+            @convert.call(value)
+          else
+            Converters.convert(@convert, value)
+          end
+        else
+          value
+        end
+      end
+
+      # Specify answer conversion
+      #
+      # @api public
+      def convert(value = (not_set = true), message = nil)
+        messages[:convert?] = message if message
+        if not_set
+          @convert
+        else
+          @convert = value
+        end
+      end
+
+      # Check if conversion is set
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def convert?
+        @convert != UndefinedSetting
+      end
+
+      # Set default value.
+      #
+      # @api public
+      def default(value = (not_set = true))
+        return @default if not_set
+
+        @default = value
+      end
+
+      # Check if default value is set
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def default?
+        @default != UndefinedSetting
+      end
+
+      # Ensure that passed argument is present or not
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def required(value = (not_set = true), message = nil)
+        messages[:required?] = message if message
+        return @required if not_set
+
+        @required = value
+      end
+      alias required? required
+
+      # Set validation rule for an argument
+      #
+      # @param [Object] value
+      #
+      # @return [Question]
+      #
+      # @api public
+      def validate(value = nil, message = nil, &block)
+        messages[:valid?] = message if message
+        @validation = (value || block)
+      end
+
+      # Prepopulate input with custom content
+      #
+      # @api public
+      def value(val)
+        return @value if val.nil?
+
+        @value = val
+      end
+
+      # Check if custom value is present
+      #
+      # @api private
+      def value?
+        @value != UndefinedSetting
+      end
+
+      def validation?
+        @validation != UndefinedSetting
+      end
+
+      # Modify string according to the rule given.
+      #
+      # @param [Symbol] rule
+      #
+      # @api public
+      def modify(*rules)
+        @modifier = rules
+      end
+
+      # Turn terminal echo on or off. This is used to secure the display so
+      # that the entered characters are not echoed back to the screen.
+      #
+      # @api public
+      def echo(value = nil)
+        return @echo if value.nil?
+
+        @echo = value
+      end
+      alias echo? echo
+
+      # Turn raw mode on or off. This enables character-based input.
+      #
+      # @api public
+      def raw(value = nil)
+        return @raw if value.nil?
+
+        @raw = value
+      end
+      alias raw? raw
+
+      # Set expected range of values
+      #
+      # @param [String] value
+      #
+      # @api public
+      def in(value = (not_set = true), message = nil)
+        messages[:range?] = message if message
+        if in? && !@in.is_a?(Range)
+          @in = Converters.convert(:range, @in)
+        end
+        return @in if not_set
+
+        @in = Converters.convert(:range, value)
+      end
+
+      # Check if range is set
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def in?
+        @in != UndefinedSetting
+      end
+
+      # Set quiet mode.
+      #
+      # @api public
+      def quiet(value)
+        @quiet = value
+      end
+
+      # @api public
+      def to_s
+        message.to_s
+      end
+
+      # String representation of this question
+      # @api public
+      def inspect
+        "#<#{self.class.name} @message=#{message}, @input=#{@input}>"
+      end
+    end # Question
+  end # Prompt
+end # TTY2

data/lib/tty2/prompt/result.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module TTY2
+  class Prompt
+    # Accumulates errors
+    class Result
+      attr_reader :question, :value, :errors
+
+      def initialize(question, value, errors = [])
+        @question = question
+        @value  = value
+        @errors = errors
+      end
+
+      def with(condition = nil, &block)
+        validator = (condition || block)
+        (new_value, validation_error) = validator.call(question, value)
+        accumulated_errors = errors + Array(validation_error)
+
+        if accumulated_errors.empty?
+          Success.new(question, new_value)
+        else
+          Failure.new(question, new_value, accumulated_errors)
+        end
+      end
+
+      def success?
+        is_a?(Success)
+      end
+
+      def failure?
+        is_a?(Failure)
+      end
+
+      class Success < Result
+      end
+
+      class Failure < Result
+      end
+    end
+  end # Prompt
+end # TTY2

data/lib/tty2/prompt/selected_choices.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module TTY2
+  class Prompt
+    # @api private
+    class SelectedChoices
+      include Enumerable
+
+      attr_reader :size
+
+      # Create selected choices
+      #
+      # @param [Array<Choice>] selected
+      # @param [Array<Integer>] indexes
+      #
+      # @api public
+      def initialize(selected = [], indexes = [])
+        @selected = selected
+        @indexes = indexes
+        @size = @selected.size
+      end
+
+      # Clear selected choices
+      #
+      # @api public
+      def clear
+        @indexes.clear
+        @selected.clear
+        @size = 0
+      end
+
+      # Iterate over selected choices
+      #
+      # @api public
+      def each(&block)
+        return to_enum unless block_given?
+
+        @selected.each(&block)
+      end
+
+      # Insert choice at index
+      #
+      # @param [Integer] index
+      # @param [Choice] choice
+      #
+      # @api public
+      def insert(index, choice)
+        insert_idx = find_index_by { |i| index < @indexes[i] }
+        insert_idx ||= -1
+        @indexes.insert(insert_idx, index)
+        @selected.insert(insert_idx, choice)
+        @size += 1
+        self
+      end
+
+      # Delete choice at index
+      #
+      # @return [Choice]
+      #   the deleted choice
+      #
+      # @api public
+      def delete_at(index)
+        delete_idx = @indexes.each_index.find { |i| index == @indexes[i] }
+        return nil unless delete_idx
+
+        @indexes.delete_at(delete_idx)
+        choice = @selected.delete_at(delete_idx)
+        @size -= 1
+        choice
+      end
+
+      def find_index_by(&search)
+        (0...@size).bsearch(&search)
+      end
+    end # SelectedChoices
+  end # Prompt
+end # TTY2