wibrfake-brk 0.0.2

data/lib/wibrfake/ty/prompt/converters.rb

@@ -0,0 +1,182 @@
+# frozen_string_literal: true
+
+require_relative "const"
+require_relative "converter_dsl"
+
+module TTY
+  class Prompt
+    module Converters
+      extend ConverterDSL
+
+      TRUE_VALUES = /^(t(rue)?|y(es)?|on|1)$/i.freeze
+      FALSE_VALUES = /^(f(alse)?|n(o)?|off|0)$/i.freeze
+
+      SINGLE_DIGIT_MATCHER = /^(?<digit>\-?\d+(\.\d+)?)$/.freeze
+      DIGIT_MATCHER = /^(?<open>-?\d+(\.\d+)?)
+                       \s*(?<sep>(\.\s*){2,3}|-|,)\s*
+                       (?<close>-?\d+(\.\d+)?)$
+                      /x.freeze
+      LETTER_MATCHER = /^(?<open>\w)
+                        \s*(?<sep>(\.\s*){2,3}|-|,)\s*
+                        (?<close>\w)$
+                       /x.freeze
+
+      converter(:boolean, :bool) do |input|
+        case input.to_s
+        when TRUE_VALUES then true
+        when FALSE_VALUES then false
+        else Const::Undefined
+        end
+      end
+
+      converter(:string, :str) do |input|
+        String(input).chomp
+      end
+
+      converter(:symbol, :sym) do |input|
+        input.to_sym
+      end
+
+      converter(:char) do |input|
+        String(input).chars.to_a[0]
+      end
+
+      converter(:date) do |input|
+        begin
+          require "date" unless defined?(::Date)
+          ::Date.parse(input)
+        rescue ArgumentError
+          Const::Undefined
+        end
+      end
+
+      converter(:datetime) do |input|
+        begin
+          require "date" unless defined?(::Date)
+          ::DateTime.parse(input.to_s)
+        rescue ArgumentError
+          Const::Undefined
+        end
+      end
+
+      converter(:time) do |input|
+        begin
+          require "time"
+          ::Time.parse(input.to_s)
+        rescue ArgumentError
+          Const::Undefined
+        end
+      end
+
+      converter(:integer, :int) do |input|
+        begin
+          Integer(input)
+        rescue ArgumentError
+          Const::Undefined
+        end
+      end
+
+      converter(:float) do |input|
+        begin
+          Float(input)
+        rescue TypeError, ArgumentError
+          Const::Undefined
+        end
+      end
+
+      # Convert string number to integer or float
+      #
+      # @return [Integer,Float,Const::Undefined]
+      #
+      # @api private
+      def cast_to_num(num)
+        ([convert(:int, num), convert(:float, num)] - [Const::Undefined]).first ||
+          Const::Undefined
+      end
+      module_function :cast_to_num
+
+      converter(:range) do |input|
+        if input.is_a?(::Range)
+          input
+        elsif match = input.to_s.match(SINGLE_DIGIT_MATCHER)
+          digit = cast_to_num(match[:digit])
+          ::Range.new(digit, digit)
+        elsif match = input.to_s.match(DIGIT_MATCHER)
+          open = cast_to_num(match[:open])
+          close = cast_to_num(match[:close])
+          ::Range.new(open, close, match[:sep].gsub(/\s*/, "") == "...")
+        elsif match = input.to_s.match(LETTER_MATCHER)
+          ::Range.new(match[:open], match[:close],
+                      match[:sep].gsub(/\s*/, "") == "...")
+        else Const::Undefined
+        end
+      end
+
+      converter(:regexp) do |input|
+        Regexp.new(input)
+      end
+
+      converter(:filepath, :file) do |input|
+        ::File.expand_path(input)
+      end
+
+      converter(:pathname, :path) do |input|
+        require "pathname" unless defined?(::Pathname)
+        ::Pathname.new(input)
+      end
+
+      converter(:uri) do |input|
+        require "uri" unless defined?(::URI)
+        ::URI.parse(input)
+      end
+
+      converter(:list, :array) do |val|
+        (val.respond_to?(:to_a) ? val : val.split(/(?<!\\),/))
+          .map { |v| v.strip.gsub(/\\,/, ",") }
+          .reject(&:empty?)
+      end
+
+      converter(:hash, :map) do |val|
+        values = val.respond_to?(:to_a) ? val : val.split(/[& ]/)
+        values.each_with_object({}) do |pair, pairs|
+          key, value = pair.split(/[=:]/, 2)
+          if (current = pairs[key.to_sym])
+            pairs[key.to_sym] = Array(current) << value
+          else
+            pairs[key.to_sym] = value
+          end
+          pairs
+        end
+      end
+
+      converter_registry.keys.each do |type|
+        next if type =~ /list|array|map|hash/
+
+        [:"#{type}_list", :"#{type}_array", :"#{type}s"].each do |new_type|
+          converter(new_type) do |val|
+            converter_registry[:array].(val).map do |obj|
+              converter_registry[type].(obj)
+            end
+          end
+        end
+
+        [:"#{type}_map", :"#{type}_hash"].each do |new_type|
+          converter(new_type) do |val|
+            converter_registry[:hash].(val).each_with_object({}) do |(k, v), h|
+              h[k] = converter_registry[type].(v)
+            end
+          end
+        end
+
+        [:"string_#{type}_map", :"str_#{type}_map",
+         :"string_#{type}_hash", :"str_#{type}_hash"].each do |new_type|
+          converter(new_type) do |val|
+            converter_registry[:hash].(val).each_with_object({}) do |(k, v), h|
+              h[converter_registry[:string].(k)] = converter_registry[type].(v)
+            end
+          end
+        end
+      end
+    end # Converters
+  end # Prompt
+end # TTY

data/lib/wibrfake/ty/prompt/distance.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module TTY
+  class Prompt
+    # A class responsible for string comparison
+    class Distance
+      # Calculate the optimal string alignment distance
+      #
+      # @api public
+      def distance(first, second)
+        distances = []
+        rows      = first.to_s.length
+        cols      = second.to_s.length
+
+        0.upto(rows) do |index|
+          distances << [index] + [0] * cols
+        end
+        distances[0] = 0.upto(cols).to_a
+
+        1.upto(rows) do |first_index|
+          1.upto(cols) do |second_index|
+            first_char  = first[first_index - 1]
+            second_char = second[second_index - 1]
+            cost        = first_char == second_char ? 0 : 1
+
+            distances[first_index][second_index] = [
+              distances[first_index - 1][second_index], # deletion
+              distances[first_index][second_index - 1],     # insertion
+              distances[first_index - 1][second_index - 1]  # substitution
+            ].min + cost
+
+            if first_index > 1 && second_index > 1
+              first_previous_char = first[first_index - 2]
+              second_previous_char = second[second_index - 2]
+              if first_char == second_previous_char && second_char == first_previous_char
+                distances[first_index][second_index] = [
+                  distances[first_index][second_index],
+                  distances[first_index - 2][second_index - 2] + 1 # transposition
+                ].min
+              end
+            end
+
+          end
+        end
+        distances[rows][cols]
+      end
+    end # Distance
+  end # Prompt
+end # TTY

data/lib/wibrfake/ty/prompt/enum_list.rb

@@ -0,0 +1,433 @@
+# frozen_string_literal: true
+
+require "English"
+
+require_relative "choices"
+require_relative "block_paginator"
+require_relative "paginator"
+
+module TTY
+  class Prompt
+    # A class reponsible for rendering enumerated list menu.
+    # Used by {Prompt} to display static choice menu.
+    #
+    # @api private
+    class EnumList
+      PAGE_HELP = "(Press tab/right or left to reveal more choices)"
+
+      # Checks type of default parameter to be integer
+      INTEGER_MATCHER = /\A[-+]?\d+\Z/.freeze
+
+      # Create instance of EnumList menu.
+      #
+      # @api public
+      def initialize(prompt, **options)
+        @prompt       = prompt
+        @prefix       = options.fetch(:prefix) { @prompt.prefix }
+        @enum         = options.fetch(:enum) { ")" }
+        @default      = options.fetch(:default, nil)
+        @active_color = options.fetch(:active_color) { @prompt.active_color }
+        @help_color   = options.fetch(:help_color)   { @prompt.help_color }
+        @error_color  = options.fetch(:error_color)  { @prompt.error_color }
+        @cycle        = options.fetch(:cycle, false)
+        @quiet        = options.fetch(:quiet) { @prompt.quiet }
+        @symbols      = @prompt.symbols.merge(options.fetch(:symbols, {}))
+        @input        = nil
+        @done         = false
+        @first_render = true
+        @failure      = false
+        @active       = @default
+        @choices      = Choices.new
+        @per_page     = options[:per_page]
+        @page_help    = options[:page_help] || PAGE_HELP
+        @paginator    = BlockPaginator.new
+        @page_active  = @default
+      end
+
+      # Change symbols used by this prompt
+      #
+      # @param [Hash] new_symbols
+      #   the new symbols to use
+      #
+      # @api public
+      def symbols(new_symbols = (not_set = true))
+        return @symbols if not_set
+
+        @symbols.merge!(new_symbols)
+      end
+
+      # Set default option selected
+      #
+      # @api public
+      def default(default)
+        @default = default
+      end
+
+      # Check if default value is set
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def default?
+        !@default.to_s.empty?
+      end
+
+      # Set number of items per page
+      #
+      # @api public
+      def per_page(value)
+        @per_page = value
+      end
+
+      def page_size
+        (@per_page || Paginator::DEFAULT_PAGE_SIZE)
+      end
+
+      # Check if list is paginated
+      #
+      # @return [Boolean]
+      #
+      # @api private
+      def paginated?
+        @choices.size > page_size
+      end
+
+      # @param [String] text
+      #   the help text to display per page
+      # @api pbulic
+      def page_help(text)
+        @page_help = text
+      end
+
+      # Set selecting active index using number pad
+      #
+      # @api public
+      def enum(value)
+        @enum = value
+      end
+
+      # Set quiet mode
+      #
+      # @api public
+      def quiet(value)
+        @quiet = value
+      end
+
+      # Add a single choice
+      #
+      # @api public
+      def choice(*value, &block)
+        if block
+          @choices << (value << block)
+        else
+          @choices << value
+        end
+      end
+
+      # Add multiple choices
+      #
+      # @param [Array[Object]] values
+      #   the values to add as choices
+      #
+      # @api public
+      def choices(values = (not_set = true))
+        if not_set
+          @choices
+        else
+          values.each { |val| @choices << val }
+        end
+      end
+
+      # Call the list menu by passing question and choices
+      #
+      # @param [String] question
+      #
+      # @param
+      # @api public
+      def call(question, possibilities, &block)
+        choices(possibilities)
+        @question = question
+        block[self] if block
+        setup_defaults
+        @prompt.subscribe(self) do
+          render
+        end
+      end
+
+      def keypress(event)
+        if %i[backspace delete].include?(event.key.name)
+          return if @input.empty?
+
+          @input.chop!
+          mark_choice_as_active
+        elsif event.value =~ /^\d+$/
+          @input += event.value
+          mark_choice_as_active
+        end
+      end
+
+      def keyreturn(*)
+        @failure = false
+        num = @input.to_i
+        choice_disabled = choices[num - 1] && choices[num - 1].disabled?
+        choice_in_range = num > 0 && num <= @choices.size
+
+        if choice_in_range && !choice_disabled || @input.empty?
+          @done = true
+        else
+          @input = ""
+          @failure = true
+        end
+      end
+      alias keyenter keyreturn
+
+      def keyright(*)
+        if (@page_active + page_size) <= @choices.size
+          @page_active += page_size
+        elsif @cycle
+          @page_active = 1
+        end
+      end
+      alias keytab keyright
+
+      def keyleft(*)
+        if (@page_active - page_size) >= 0
+          @page_active -= page_size
+        elsif @cycle
+          @page_active = @choices.size - 1
+        end
+      end
+
+      private
+
+      # Find active choice or set to default
+      #
+      # @return [nil]
+      #
+      # @api private
+      def mark_choice_as_active
+        next_active = @choices[@input.to_i - 1]
+
+        if next_active && next_active.disabled?
+          # noop
+        elsif (@input.to_i > 0) && next_active
+          @active = @input.to_i
+        else
+          @active = @default
+        end
+        @page_active = @active
+      end
+
+      # Validate default indexes to be within range
+      #
+      # @api private
+      def validate_defaults
+        msg = if @default.nil? || @default.to_s.empty?
+                "default index must be an integer in range (1 - #{choices.size})"
+              elsif @default.to_s !~ INTEGER_MATCHER
+                validate_default_name
+              elsif @default < 1 || @default > @choices.size
+                "default index #{@default} out of range (1 - #{@choices.size})"
+              elsif choices[@default - 1] && choices[@default - 1].disabled?
+                "default index #{@default} matches disabled choice item"
+              end
+
+        raise(ConfigurationError, msg) if msg
+      end
+
+      # Validate default choice name
+      #
+      # @return [String]
+      #
+      # @api private
+      def validate_default_name
+        default_choice = choices.find_by(:name, @default.to_s)
+        if default_choice.nil?
+          "no choice found for the default name: #{@default.inspect}"
+        elsif default_choice.disabled?
+          "default name #{@default.inspect} matches disabled choice"
+        end
+      end
+
+      # Setup default option and active selection
+      #
+      # @api private
+      def setup_defaults
+        if @default.to_s.empty?
+          @default = (0..choices.length).find { |i| !choices[i].disabled? } + 1
+        end
+        validate_defaults
+        if default_choice = choices.find_by(:name, @default)
+          @default = choices.index(default_choice) + 1
+        end
+        mark_choice_as_active
+      end
+
+      # Render a selection list.
+      #
+      # By default the result is printed out.
+      #
+      # @return [Object] value
+      #   return the selected value
+      #
+      # @api private
+      def render
+        @input = ""
+        until @done
+          question = render_question
+          @prompt.print(question)
+          @prompt.print(render_error) if @failure
+          if paginated? && !@done
+            @prompt.print(render_page_help)
+          end
+          @prompt.read_keypress
+          question_lines = question.split($INPUT_RECORD_SEPARATOR, -1)
+          @prompt.print(refresh(question_lines_count(question_lines)))
+        end
+        @prompt.print(render_question) unless @quiet
+        answer
+      end
+
+      # Count how many screen lines the question spans
+      #
+      # @return [Integer]
+      #
+      # @api private
+      def question_lines_count(question_lines)
+        question_lines.reduce(0) do |acc, line|
+          acc + @prompt.count_screen_lines(line)
+        end
+      end
+
+      # Find value for the choice selected
+      #
+      # @return [nil, Object]
+      #
+      # @api private
+      def answer
+        @choices[@active - 1].value
+      end
+
+      # Determine area of the screen to clear
+      #
+      # @param [Integer] lines
+      #   the lines to clear
+      #
+      # @return [String]
+      #
+      # @api private
+      def refresh(lines)
+        @prompt.clear_lines(lines) +
+          @prompt.cursor.clear_screen_down
+      end
+
+      # Render question with the menu options
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_question
+        header = ["#{@prefix}#{@question} #{render_header}\n"]
+        unless @done
+          header << render_menu
+          header << render_footer
+        end
+        header.join
+      end
+
+      # Error message when incorrect index chosen
+      #
+      # @api private
+      def error_message
+        error = "Please enter a valid number"
+        "\n" + @prompt.decorate(">>", @error_color) + " " + error
+      end
+
+      # Render error message and return cursor to position of input
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_error
+        error = error_message.dup
+        if !paginated?
+          error << @prompt.cursor.prev_line
+          error << @prompt.cursor.forward(render_footer.size)
+        end
+        error
+      end
+
+      # Render chosen option
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_header
+        return "" unless @done
+        return "" unless @active
+
+        selected_item = @choices[@active - 1].name.to_s
+        @prompt.decorate(selected_item, @active_color)
+      end
+
+      # Render footer for the indexed menu
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_footer
+        "  Choose 1-#{@choices.size} [#{@default}]: #{@input}"
+      end
+
+      # Pagination help message
+      #
+      # @return [String]
+      #
+      # @api private
+      def page_help_message
+        return "" unless paginated?
+
+        "\n" + @prompt.decorate(@page_help, @help_color)
+      end
+
+      # Render page help
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_page_help
+        help = page_help_message.dup
+        if @failure
+          help << @prompt.cursor.prev_line
+        end
+        help << @prompt.cursor.prev_line
+        help << @prompt.cursor.forward(render_footer.size)
+      end
+
+      # Render menu with indexed choices to select from
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_menu
+        output = []
+
+        @paginator.paginate(@choices, @page_active, @per_page) do |choice, index|
+          num = (index + 1).to_s + @enum + " "
+          selected = num.to_s + choice.name.to_s
+          output << if index + 1 == @active && !choice.disabled?
+                      (" " * 2) + @prompt.decorate(selected, @active_color)
+                    elsif choice.disabled?
+                      @prompt.decorate(@symbols[:cross], :red) + " " +
+                      selected + " " + choice.disabled.to_s
+                    else
+                      (" " * 2) + selected
+                    end
+          output << "\n"
+        end
+
+        output.join
+      end
+    end # EnumList
+  end # Prompt
+end # TTY

data/lib/wibrfake/ty/prompt/errors.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module TTY
+  class Prompt
+    Error = Class.new(StandardError)
+
+    # Raised when wrong parameter is used to configure prompt
+    ConfigurationError = Class.new(Error)
+
+    # Raised when type conversion cannot be performed
+    ConversionError = Class.new(Error)
+
+    # Raised when the passed in validation argument is of wrong type
+    ValidationCoercion = Class.new(Error)
+
+    # Raised when the required argument is not supplied
+    ArgumentRequired = Class.new(Error)
+
+    # Raised when the argument validation fails
+    ArgumentValidation = Class.new(Error)
+
+    # Raised when the argument is not expected
+    InvalidArgument = Class.new(Error)
+
+    # Raised when overriding already defined conversion
+    ConversionAlreadyDefined = Class.new(Error)
+
+    # Raised when conversion type isn't registered
+    UnsupportedConversion = Class.new(Error)
+  end # Prompt
+end # TTY