wibrfake-brk 0.0.2

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

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+require_relative "list"
+require_relative "selected_choices"
+
+module TTY
+  class Prompt
+    # A class responsible for rendering multi select list menu.
+    # Used by {Prompt} to display interactive choice menu.
+    #
+    # @api private
+    class MultiList < List
+      # Create instance of TTY::Prompt::MultiList menu.
+      #
+      # @param [Prompt] :prompt
+      # @param [Hash] options
+      #
+      # @api public
+      def initialize(prompt, **options)
+        super
+        @selected = SelectedChoices.new
+        @help = options[:help]
+        @echo = options.fetch(:echo, true)
+        @min  = options[:min]
+        @max  = options[:max]
+      end
+
+      # Set a minimum number of choices
+      #
+      # @api public
+      def min(value)
+        @min = value
+      end
+
+      # Set a maximum number of choices
+      #
+      # @api public
+      def max(value)
+        @max = value
+      end
+
+      # Callback fired when enter/return key is pressed
+      #
+      # @api private
+      def keyenter(*)
+        valid = true
+        valid = @min <= @selected.size if @min
+        valid = @selected.size <= @max if @max
+
+        super if valid
+      end
+      alias keyreturn keyenter
+
+      # Callback fired when space key is pressed
+      #
+      # @api private
+      def keyspace(*)
+        active_choice = choices[@active - 1]
+        if @selected.include?(active_choice)
+          @selected.delete_at(@active - 1)
+        else
+          return if @max && @selected.size >= @max
+
+          @selected.insert(@active - 1, active_choice)
+        end
+      end
+
+      # Selects all choices when Ctrl+A is pressed
+      #
+      # @api private
+      def keyctrl_a(*)
+        return if @max && @max < choices.size
+
+        @selected = SelectedChoices.new(choices.enabled, choices.enabled_indexes)
+      end
+
+      # Revert currently selected choices when Ctrl+I is pressed
+      #
+      # @api private
+      def keyctrl_r(*)
+        return if @max && @max < choices.size
+
+        indexes = choices.each_with_index.reduce([]) do |acc, (choice, idx)|
+                    acc << idx if !choice.disabled? && !@selected.include?(choice)
+                    acc
+                  end
+        @selected = SelectedChoices.new(choices.enabled - @selected.to_a, indexes)
+      end
+
+      private
+
+      # Setup default options and active selection
+      #
+      # @api private
+      def setup_defaults
+        validate_defaults
+        # At this stage, @choices matches all the visible choices.
+        default_indexes = @default.map do |d|
+          if d.to_s =~ INTEGER_MATCHER
+            d - 1
+          else
+            choices.index(choices.find_by(:name, d.to_s))
+          end
+        end
+        @selected = SelectedChoices.new(@choices.values_at(*default_indexes),
+                                        default_indexes)
+
+        if @default.empty?
+          # no default, pick the first non-disabled choice
+          @active = choices.index { |choice| !choice.disabled? } + 1
+        elsif @default.last.to_s =~ INTEGER_MATCHER
+          @active = @default.last
+        elsif default_choice = choices.find_by(:name, @default.last.to_s)
+          @active = choices.index(default_choice) + 1
+        end
+      end
+
+      # Generate selected items names
+      #
+      # @return [String]
+      #
+      # @api private
+      def selected_names
+        @selected.map(&:name).join(", ")
+      end
+
+      # Header part showing the minimum/maximum number of choices
+      #
+      # @return [String]
+      #
+      # @api private
+      def minmax_help
+        help = []
+        help << "min. #{@min}" if @min
+        help << "max. #{@max}" if @max
+        "(%s) " % [help.join(", ")]
+      end
+
+      # Build a default help text
+      #
+      # @return [String]
+      #
+      # @api private
+      def default_help
+        str = []
+        str << "(Press "
+        str << "#{arrows_help} arrow"
+        str << " or 1-#{choices.size} number" if enumerate?
+        str << " to move, Space"
+        str << "/Ctrl+A|R" if @max.nil?
+        str << " to select"
+        str << " (all|rev)" if @max.nil?
+        str << (filterable? ? "," : " and")
+        str << " Enter to finish"
+        str << " and letters to filter" if filterable?
+        str << ")"
+        str.join
+      end
+
+      # Render initial help text and then currently selected choices
+      #
+      # @api private
+      def render_header
+        instructions = @prompt.decorate(help, @help_color)
+        minmax_suffix = @min || @max ? minmax_help : ""
+        print_selected = @selected.size.nonzero? && @echo
+
+        if @done && @echo
+          @prompt.decorate(selected_names, @active_color)
+        elsif (@first_render && (help_start? || help_always?)) ||
+              (help_always? && !@filter.any? && !@done)
+          minmax_suffix +
+            (print_selected ? "#{selected_names} " : "") +
+            instructions
+        elsif filterable? && @filter.any?
+          minmax_suffix +
+            (print_selected ? "#{selected_names} " : "") +
+            @prompt.decorate(filter_help, @help_color)
+        else
+          minmax_suffix + (print_selected ? selected_names : "")
+        end
+      end
+
+      # All values for the choices selected
+      #
+      # @return [Array[nil,Object]]
+      #
+      # @api private
+      def answer
+        @selected.map(&:value)
+      end
+
+      # Render menu with choices to select from
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_menu
+        output = []
+
+        sync_paginators if @paging_changed
+        paginator.paginate(choices, @active, @per_page) do |choice, index|
+          num = enumerate? ? (index + 1).to_s + @enum + " " : ""
+          indicator = (index + 1 == @active) ?  @symbols[:marker] : " "
+          indicator += " "
+          message = if @selected.include?(choice) && !choice.disabled?
+                      selected = @prompt.decorate(@symbols[:radio_on], @active_color)
+                      "#{selected} #{num}#{choice.name}"
+                    elsif choice.disabled?
+                      @prompt.decorate(@symbols[:cross], :red) +
+                        " #{num}#{choice.name} #{choice.disabled}"
+                    else
+                      "#{@symbols[:radio_off]} #{num}#{choice.name}"
+                    end
+          end_index = paginated? ? paginator.end_index : choices.size - 1
+          newline = (index == end_index) ? "" : "\n"
+          output << indicator + message + newline
+        end
+
+        output.join
+      end
+    end # MultiList
+  end # Prompt
+end # TTY

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

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "question"
+require_relative "symbols"
+
+module TTY
+  class Prompt
+    # A prompt responsible for multi line user input
+    #
+    # @api private
+    class Multiline < Question
+      HELP = "(Press Ctrl+D or Ctrl+Z to finish)".freeze
+
+      def initialize(prompt, **options)
+        super
+        @help         = options[:help] || self.class::HELP
+        @first_render = true
+        @lines_count  = 0
+      end
+
+      # Provide help information
+      #
+      # @return [String]
+      #
+      # @api public
+      def help(value = (not_set = true))
+        return @help if not_set
+
+        @help = value
+      end
+
+      def read_input
+        @prompt.read_multiline
+      end
+
+      def keyreturn(*)
+        @lines_count += 1
+      end
+      alias keyenter keyreturn
+
+      def render_question
+        header = ["#{@prefix}#{message} "]
+        if !echo?
+          header
+        elsif @done
+          header << @prompt.decorate(@input.to_s, @active_color)
+        elsif @first_render
+          header << @prompt.decorate(help, @help_color)
+          @first_render = false
+        end
+        header << "\n"
+        header.join
+      end
+
+      def process_input(question)
+        @prompt.print(question)
+        @lines = read_input
+        @input = "#{@lines.first.strip} ..." unless @lines.first.to_s.empty?
+        if Utils.blank?(@input) && default?
+          @input = default
+          @lines = default
+        end
+        @evaluator.(@lines)
+      end
+
+      def refresh(lines, lines_to_clear)
+        size = @lines_count + lines_to_clear + 1
+        @prompt.clear_lines(size)
+      end
+    end # Multiline
+  end # Prompt
+end # TTY

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

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module TTY
+  class Prompt
+    class Paginator
+      DEFAULT_PAGE_SIZE = 6
+
+      # The 0-based index of the first item on this page
+      attr_accessor :start_index
+
+      # The 0-based index of the last item on this page
+      attr_reader :end_index
+
+      # The 0-based index of the active item on this page
+      attr_reader :current_index
+
+      # The 0-based index of the previously active item on this page
+      attr_reader :last_index
+
+      # Create a Paginator
+      #
+      # @api private
+      def initialize(**options)
+        @last_index  = Array(options[:default]).flatten.first || 0
+        @per_page    = options[:per_page]
+        @start_index = Array(options[:default]).flatten.first
+      end
+
+      # Reset current page indexes
+      #
+      # @api private
+      def reset!
+        @start_index = nil
+        @end_index   = nil
+      end
+
+      # Check if page size is valid
+      #
+      # @raise [InvalidArgument]
+      #
+      # @api private
+      def check_page_size!
+        raise InvalidArgument, "per_page must be > 0" if @per_page < 1
+      end
+
+      # Paginate collection given an active index
+      #
+      # @param [Array[Choice]] list
+      #   a collection of choice items
+      # @param [Integer] active
+      #   current choice active index
+      # @param [Integer] per_page
+      #   number of choice items per page
+      #
+      # @return [Enumerable]
+      #   the list between start and end index
+      #
+      # @api public
+      def paginate(list, active, per_page = nil, &block)
+        current_index = active - 1
+        default_size = (list.size <= DEFAULT_PAGE_SIZE ? list.size : DEFAULT_PAGE_SIZE)
+        @per_page = @per_page || per_page || default_size
+        check_page_size!
+        @start_index ||= (current_index / @per_page) * @per_page
+        @end_index ||= @start_index + @per_page - 1
+
+        # Don't paginate short lists
+        if list.size <= @per_page
+          @start_index = 0
+          @end_index = list.size - 1
+          if block
+            return list.each_with_index(&block)
+          else
+            return list.each_with_index.to_enum
+          end
+        end
+
+        step = (current_index - @last_index).abs
+        if current_index > @last_index # going up
+          if current_index >= @end_index && current_index < list.size - 1
+            last_page = list.size - @per_page
+            @start_index = [@start_index + step, last_page].min
+          end
+        elsif current_index < @last_index # going down
+          if current_index <= @start_index && current_index > 0
+            @start_index = [@start_index - step, 0].max
+          end
+        end
+
+        # Cycle list
+        if current_index.zero?
+          @start_index = 0
+        elsif current_index == list.size - 1
+          @start_index = list.size - 1 - (@per_page - 1)
+        end
+
+        @end_index = @start_index + (@per_page - 1)
+        @last_index = current_index
+
+        sliced_list = list[@start_index..@end_index]
+        page_range = (@start_index..@end_index)
+
+        return sliced_list.zip(page_range).to_enum unless block_given?
+
+        sliced_list.each_with_index do |item, index|
+          block[item, @start_index + index]
+        end
+      end
+    end # Paginator
+  end # Prompt
+end # TTY

data/lib/wibrfake/ty/prompt/question/checks.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative "../const"
+
+module TTY
+  class Prompt
+    class Question
+      module Checks
+        # Check if modifications are applicable
+        class CheckModifier
+          def self.call(question, value)
+            if !question.modifier.nil? || question.modifier
+              [Modifier.new(question.modifier).apply_to(value)]
+            else
+              [value]
+            end
+          end
+        end
+
+        # Check if value is within range
+        class CheckRange
+          def self.float?(value)
+            !/[-+]?(\d*[.])?\d+/.match(value.to_s).nil?
+          end
+
+          def self.int?(value)
+            !/^[-+]?\d+$/.match(value.to_s).nil?
+          end
+
+          def self.cast(value)
+            if float?(value)
+              value.to_f
+            elsif int?(value)
+              value.to_i
+            else
+              value
+            end
+          end
+
+          def self.call(question, value)
+            if !question.in? ||
+              (question.in? && question.in.include?(cast(value)))
+              [value]
+            else
+              tokens = { value: value, in: question.in }
+              [value, question.message_for(:range?, tokens)]
+            end
+          end
+        end
+
+        # Check if input requires validation
+        class CheckValidation
+          def self.call(question, value)
+            if !question.validation? || (question.required? && value.nil?) ||
+              (question.validation? &&
+                Validation.new(question.validation).call(value))
+              [value]
+            else
+              tokens = { valid: question.validation.inspect, value: value }
+              [value, question.message_for(:valid?, tokens)]
+            end
+          end
+        end
+
+        # Check if default value provided
+        class CheckDefault
+          def self.call(question, value)
+            if value.nil? && question.default?
+              [question.default]
+            else
+              [value]
+            end
+          end
+        end
+
+        # Check if input is required
+        class CheckRequired
+          def self.call(question, value)
+            if question.required? && !question.default? && value.nil?
+              [value, question.message_for(:required?)]
+            else
+              [value]
+            end
+          end
+        end
+
+        class CheckConversion
+          def self.call(question, value)
+            if question.convert? && !Utils.blank?(value)
+              result = question.convert_result(value)
+              if result == Const::Undefined
+                tokens = { value: value, type: question.convert }
+                [value, question.message_for(:convert?, tokens)]
+              else
+                [result]
+              end
+            else
+              [value]
+            end
+          end
+        end
+      end # Checks
+    end # Question
+  end # Prompt
+end # TTY

data/lib/wibrfake/ty/prompt/question/modifier.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module TTY
+  class Prompt
+    class Question
+      # A class representing String modifications.
+      class Modifier
+        attr_reader :modifiers
+
+        # Initialize a Modifier
+        #
+        # @api public
+        def initialize(modifiers)
+          @modifiers = modifiers
+        end
+
+        # Change supplied value according to the given string transformation.
+        # Valid settings are:
+        #
+        # @param [String] value
+        #   the string to be modified
+        #
+        # @return [String]
+        #
+        # @api private
+        def apply_to(value)
+          modifiers.reduce(value) do |result, mod|
+            result = Modifier.letter_case(mod, result)
+            Modifier.whitespace(mod, result)
+          end
+        end
+
+        # Changes letter casing in a string according to valid modifications.
+        # For invalid modification option the string is preserved.
+        #
+        # @param [Symbol] mod
+        #  the modification to change the string
+        #
+        # @option mod [Symbol] :up        change to upper case
+        # @option mod [Symbol] :upcase    change to upper case
+        # @option mod [Symbol] :uppercase change to upper case
+        # @option mod [Symbol] :down      change to lower case
+        # @option mod [Symbol] :downcase  change to lower case
+        # @option mod [Symbol] :capitalize change all words to start
+        #                                  with uppercase case letter
+        #
+        # @return [String]
+        #
+        # @api public
+        def self.letter_case(mod, value)
+          return value unless value.is_a?(String)
+
+          case mod
+          when :up, :upcase, :uppercase
+            value.upcase
+          when :down, :downcase, :lowercase
+            value.downcase
+          when :capitalize
+            value.capitalize
+          else
+            value
+          end
+        end
+
+        # Changes whitespace in a string according to valid modifications.
+        #
+        # @param [Symbol] mod
+        #   the modification to change the string
+        #
+        # @option mod [String] :trim, :strip
+        #   remove whitespace for the start and end
+        # @option mod [String] :chomp     remove record separator from the end
+        # @option mod [String] :collapse  remove any duplicate whitespace
+        # @option mod [String] :remove    remove all whitespace
+        #
+        # @api public
+        def self.whitespace(mod, value)
+          return value unless value.is_a?(String)
+
+          case mod
+          when :trim, :strip
+            value.strip
+          when :chomp
+            value.chomp
+          when :collapse
+            value.gsub(/\s+/, " ")
+          when :remove
+            value.gsub(/\s+/, "")
+          else
+            value
+          end
+        end
+      end # Modifier
+    end # Question
+  end # Prompt
+end # TTY

data/lib/wibrfake/ty/prompt/question/validation.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module TTY
+  class Prompt
+    class Question
+      # A class representing question validation.
+      class Validation
+       # Available validator names
+        VALIDATORS = {
+          email: /^[a-z0-9._%+-]+@([a-z0-9-]+\.)+[a-z]{2,6}$/i
+        }.freeze
+
+        attr_reader :pattern
+
+        # Initialize a Validation
+        #
+        # @param [Object] pattern
+        #
+        # @return [undefined]
+        #
+        # @api private
+        def initialize(pattern)
+          @pattern = coerce(pattern)
+        end
+
+        # Convert validation into known type.
+        #
+        # @param [Object] pattern
+        #
+        # @raise [TTY::ValidationCoercion]
+        #   raised when failed to convert validation
+        #
+        # @api private
+        def coerce(pattern)
+          case pattern
+          when String, Symbol, Proc
+            pattern
+          when Regexp
+            Regexp.new(pattern.to_s)
+          else
+            raise ValidationCoercion, "Wrong type, got #{pattern.class}"
+          end
+        end
+
+        # Test if the input passes the validation
+        #
+        # @example
+        #   Validation.new(/pattern/)
+        #   validation.call(input) # => true
+        #
+        # @param [Object] input
+        #  the input to validate
+        #
+        # @return [Boolean]
+        #
+        # @api public
+        def call(input)
+          if pattern.is_a?(String) || pattern.is_a?(Symbol)
+            VALIDATORS.key?(pattern.to_sym)
+            !VALIDATORS[pattern.to_sym].match(input.to_s).nil?
+          elsif pattern.is_a?(Regexp)
+            !pattern.match(input.to_s).nil?
+          elsif pattern.is_a?(Proc)
+            result = pattern.call(input.to_s)
+            result.nil? ? false : result
+          else false
+          end
+        end
+      end # Validation
+    end # Question
+  end # Prompt
+end # TTY