wibrfake-brk 0.0.2

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

@@ -0,0 +1,286 @@
+# frozen_string_literal: true
+
+module TTY
+  # A class responsible for shell prompt interactions.
+  class Prompt
+    # A class responsible for gathering numeric input from range
+    #
+    # @api public
+    class Slider
+      HELP = "(Use %s arrow keys, press Enter to select)"
+
+      FORMAT = ":slider %s"
+
+      # Initailize a Slider
+      #
+      # @param [Prompt] prompt
+      #   the prompt
+      # @param [Hash] options
+      #   the options to configure this slider
+      # @option options [Integer] :min The minimum value
+      # @option options [Integer] :max The maximum value
+      # @option options [Integer] :step The step value
+      # @option options [String] :format The display format
+      #
+      # @api public
+      def initialize(prompt, **options)
+        @prompt       = prompt
+        @prefix       = options.fetch(:prefix) { @prompt.prefix }
+        @choices      = Choices.new
+        @min          = options.fetch(:min, 0)
+        @max          = options.fetch(:max, 10)
+        @step         = options.fetch(:step, 1)
+        @default      = options[:default]
+        @active_color = options.fetch(:active_color) { @prompt.active_color }
+        @help_color   = options.fetch(:help_color) { @prompt.help_color }
+        @format       = options.fetch(:format) { FORMAT }
+        @quiet        = options.fetch(:quiet) { @prompt.quiet }
+        @help         = options[:help]
+        @show_help    = options.fetch(:show_help) { :start }
+        @symbols      = @prompt.symbols.merge(options.fetch(:symbols, {}))
+        @first_render = true
+        @done         = false
+      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
+
+      # Setup initial active position
+      #
+      # @return [Integer]
+      #
+      # @api private
+      def initial
+        if @default.nil?
+          # no default - choose the middle option
+          choices.size / 2
+        elsif default_choice = choices.find_by(:name, @default)
+          # found a Choice by name - use it
+          choices.index(default_choice)
+        else
+          # default is the index number
+          @default - 1
+        end
+      end
+
+      # Default help text
+      #
+      # @api public
+      def default_help
+        arrows = @symbols[:arrow_left] + "/" + @symbols[:arrow_right]
+        sprintf(HELP, arrows)
+      end
+
+      # Set help text
+      #
+      # @param [String] text
+      #
+      # @api private
+      def help(text = (not_set = true))
+        return @help if !@help.nil? && not_set
+
+        @help = (@help.nil? && not_set) ? default_help : text
+      end
+
+      # Change when help is displayed
+      #
+      # @api public
+      def show_help(value = (not_set = true))
+        return @show_ehlp if not_set
+
+        @show_help = value
+      end
+
+      # @api public
+      def default(value)
+        @default = value
+      end
+
+      # @api public
+      def min(value)
+        @min = value
+      end
+
+      # @api public
+      def max(value)
+        @max = value
+      end
+
+      # @api public
+      def step(value)
+        @step = 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
+
+      # @api public
+      def format(value)
+        @format = value
+      end
+
+      # Set quiet mode.
+      #
+      # @api public
+      def quiet(value)
+        @quiet = value
+      end
+
+      # Call the slider by passing question
+      #
+      # @param [String] question
+      #   the question to ask
+      #
+      # @apu public
+      def call(question, possibilities = nil, &block)
+        @question = question
+        choices(possibilities) if possibilities
+        block.call(self) if block
+        # set up a Choices collection for min, max, step
+        # if no possibilities were supplied
+        choices((@min..@max).step(@step).to_a) if @choices.empty?
+
+        @active = initial
+        @prompt.subscribe(self) do
+          render
+        end
+      end
+
+      def keyleft(*)
+        @active -= 1 if @active > 0
+      end
+      alias keydown keyleft
+
+      def keyright(*)
+        @active += 1 if (@active + 1) < choices.size
+      end
+      alias keyup keyright
+
+      def keyreturn(*)
+        @done = true
+      end
+      alias keyspace keyreturn
+      alias keyenter keyreturn
+
+      private
+
+      # Check if help is shown only on start
+      #
+      # @api private
+      def help_start?
+        @show_help =~ /start/i
+      end
+
+      # Check if help is always displayed
+      #
+      # @api private
+      def help_always?
+        @show_help =~ /always/i
+      end
+
+      # Render an interactive range slider.
+      #
+      # @api private
+      def render
+        @prompt.print(@prompt.hide)
+        until @done
+          question = render_question
+          @prompt.print(question)
+          @prompt.read_keypress
+          refresh(question.lines.count)
+        end
+        @prompt.print(render_question) unless @quiet
+        answer
+      ensure
+        @prompt.print(@prompt.show)
+      end
+
+      # Clear screen
+      #
+      # @param [Integer] lines
+      #   the lines to clear
+      #
+      # @api private
+      def refresh(lines)
+        @prompt.print(@prompt.clear_lines(lines))
+      end
+
+      # @return [Integer, String]
+      #
+      # @api private
+      def answer
+        choices[@active].value
+      end
+
+      # Render question with the slider
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_question
+        header = ["#{@prefix}#{@question} "]
+        if @done
+          header << @prompt.decorate(choices[@active].to_s, @active_color)
+          header << "\n"
+        else
+          header << render_slider
+        end
+        if @first_render && (help_start? || help_always?) ||
+            (help_always? && !@done)
+          header << "\n" + @prompt.decorate(help, @help_color)
+          @first_render = false
+        end
+        header.join
+      end
+
+      # Render slider representation
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_slider
+        slider = (@symbols[:line] * @active) +
+                 @prompt.decorate(@symbols[:bullet], @active_color) +
+                 (@symbols[:line] * (choices.size - @active - 1))
+        value = choices[@active].name
+        case @format
+        when Proc
+          @format.call(slider, value)
+        else
+          @format.gsub(":slider", slider) % [value]
+        end
+      end
+    end # Slider
+  end # Prompt
+end # TTY

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

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module TTY
+  # A class responsible for shell prompt interactions.
+  class Prompt
+    # A class representing a statement output to prompt.
+    class Statement
+      # Flag to display newline
+      #
+      # @api public
+      attr_reader :newline
+
+      # Color used to display statement
+      #
+      # @api public
+      attr_reader :color
+
+      # Initialize a Statement
+      #
+      # @param [TTY::Prompt] prompt
+      #
+      # @param [Hash] options
+      #
+      # @option options [Symbol] :newline
+      #   force a newline break after the message
+      #
+      # @option options [Symbol] :color
+      #   change the message display to color
+      #
+      # @api public
+      def initialize(prompt, newline: true, color: false)
+        @prompt  = prompt
+        @newline = newline
+        @color   = color
+      end
+
+      # Output the message to the prompt
+      #
+      # @param [String] message
+      #   the message to be printed to stdout
+      #
+      # @api public
+      def call(message)
+        message = @prompt.decorate(message, *color) if color
+
+        if newline && /( |\t)(\e\[\d+(;\d+)*m)?\Z/ !~ message
+          @prompt.puts message
+        else
+          @prompt.print message
+          @prompt.flush
+        end
+      end
+    end # Statement
+  end # Prompt
+end # TTY

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

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative "distance"
+
+module TTY
+  # A class responsible for terminal prompt interactions.
+  class Prompt
+    # A class representing a suggestion out of possible choices
+    #
+    # @api public
+    class Suggestion
+      DEFAULT_INDENT = 8
+
+      SINGLE_TEXT    = "Did you mean this?"
+
+      PLURAL_TEXT    = "Did you mean one of these?"
+
+      # Number of spaces
+      #
+      # @api public
+      attr_reader :indent
+
+      # Text for a single suggestion
+      #
+      # @api public
+      attr_reader :single_text
+
+      # Text for multiple suggestions
+      #
+      # @api public
+      attr_reader :plural_text
+
+      # Initialize a Suggestion
+      #
+      # @api public
+      def initialize(**options)
+        @indent      = options.fetch(:indent) { DEFAULT_INDENT }
+        @single_text = options.fetch(:single_text) { SINGLE_TEXT }
+        @plural_text = options.fetch(:plural_text) { PLURAL_TEXT }
+        @suggestions = []
+        @comparator  = Distance.new
+      end
+
+      # Suggest matches out of possibile strings
+      #
+      # @param [String] message
+      #
+      # @param [Array[String]] possibilities
+      #
+      # @api public
+      def suggest(message, possibilities)
+        distances        = measure_distances(message, possibilities)
+        minimum_distance = distances.keys.min
+        max_distance     = distances.keys.max
+
+        if minimum_distance < max_distance
+          @suggestions = distances[minimum_distance].sort
+        end
+        evaluate
+      end
+
+      private
+
+      # Measure distances between messag and possibilities
+      #
+      # @param [String] message
+      #
+      # @param [Array[String]] possibilities
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def measure_distances(message, possibilities)
+        distances = Hash.new { |hash, key| hash[key] = [] }
+
+        possibilities.each do |possibility|
+          distances[@comparator.distance(message, possibility)] << possibility
+        end
+        distances
+      end
+
+      # Build up a suggestion string
+      #
+      # @param [Array[String]] suggestions
+      #
+      # @return [String]
+      #
+      # @api private
+      def evaluate
+        return @suggestions if @suggestions.empty?
+
+        if @suggestions.one?
+          build_single_suggestion
+        else
+          build_multiple_suggestions
+        end
+      end
+
+      # @api private
+      def build_single_suggestion
+        single_text + "\n" + (" " * indent) + @suggestions.first
+      end
+
+      # @api private
+      def build_multiple_suggestions
+        plural_text + "\n" +
+        @suggestions.map do |sugest|
+          " " * indent + sugest
+        end.join("\n")
+      end
+    end # Suggestion
+  end # Prompt
+end # TTY

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

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module TTY
+  class Prompt
+    # Cross platform common Unicode symbols.
+    #
+    # @api public
+    module Symbols
+      KEYS = {
+        tick: "✓",
+        cross: "✘",
+        star: "★",
+        square: "◼",
+        square_empty: "◻",
+        dot: "•",
+        bullet: "●",
+        bullet_empty: "○",
+        marker: "‣",
+        line: "─",
+        pipe: "|",
+        ellipsis: "…",
+        radio_on: "⬢",
+        radio_off: "⬡",
+        checkbox_on: "☒",
+        checkbox_off: "☐",
+        circle: "◯",
+        circle_on: "ⓧ",
+        circle_off: "Ⓘ",
+        arrow_up: "↑",
+        arrow_down: "↓",
+        arrow_up_down: "↕",
+        arrow_left: "←",
+        arrow_right: "→",
+        arrow_left_right: "↔",
+        heart: "♥",
+        diamond: "♦",
+        club: "♣",
+        spade: "♠"
+      }.freeze
+
+      WIN_KEYS = {
+        tick: "√",
+        cross: "x",
+        star: "*",
+        square: "[█]",
+        square_empty: "[ ]",
+        dot: ".",
+        bullet: "O",
+        bullet_empty: "○",
+        marker: ">",
+        line: "-",
+        pipe: "|",
+        ellipsis: "...",
+        radio_on: "(*)",
+        radio_off: "( )",
+        checkbox_on: "[×]",
+        checkbox_off: "[ ]",
+        circle: "( )",
+        circle_on: "(x)",
+        circle_off: "( )",
+        arrow_up: "↑",
+        arrow_down: "↓",
+        arrow_up_down: "↕",
+        arrow_left: "←",
+        arrow_right: "→",
+        arrow_left_right: "↔",
+        heart: "♥",
+        diamond: "♦",
+        club: "♣",
+        spade: "♠"
+      }.freeze
+
+      def symbols
+        @symbols ||= windows? ? WIN_KEYS : KEYS
+      end
+      module_function :symbols
+
+      # Check if Windowz
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def windows?
+        ::File::ALT_SEPARATOR == "\\"
+      end
+      module_function :windows?
+    end # Symbols
+  end # Prompt
+end # TTY

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "stringio"
+
+require_relative "../prompt"
+
+module TTY
+  # Used for initializing test cases
+  class Prompt
+    module StringIOExtensions
+      def wait_readable(*)
+        true
+      end
+
+      def ioctl(*)
+        80
+      end
+    end
+
+    class Test < TTY::Prompt
+      def initialize(**options)
+        @input = StringIO.new
+        @input.extend(StringIOExtensions)
+        @output = StringIO.new
+
+        options.merge!({
+          input: @input,
+          output: @output,
+          env: { "TTY_TEST" => true },
+          enable_color: options.fetch(:enable_color, true)
+        })
+        super(**options)
+      end
+    end # Test
+  end # Prompt
+end # TTY

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module TTY
+  class Prompt
+    class Timer
+      attr_reader :duration
+
+      attr_reader :total
+
+      attr_reader :interval
+
+      def initialize(duration, interval)
+        @duration = duration
+        @interval = interval
+        @total = 0.0
+        @current = nil
+        @events = []
+      end
+
+      def start
+        return if @current
+
+        @current = time_now
+      end
+
+      def stop
+        return unless @current
+
+        @current = nil
+      end
+
+      def runtime
+        time_now - @current
+      end
+
+      def on_tick(&block)
+        @events << block
+      end
+
+      def while_remaining
+        start
+        remaining = duration
+
+        if @duration
+          while remaining >= 0.0
+            if runtime >= total
+              tick = duration - @total
+              @events.each { |block| block.(tick) }
+              @total += @interval
+            end
+
+            yield(remaining)
+            remaining = duration - runtime
+          end
+        else
+          loop { yield }
+        end
+      ensure
+        stop
+      end
+
+      if defined?(Process::CLOCK_MONOTONIC)
+        # Object representing current time
+        def time_now
+          ::Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        end
+      else
+        # Object represeting current time
+        def time_now
+          ::Time.now
+        end
+      end
+    end # Timer
+  end # Prompt
+end # TTY

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

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module TTY
+  module Utils
+    module_function
+
+    BLANK_REGEX = /\A[[:space:]]*\z/o.freeze
+
+    # Extract options hash from array argument
+    #
+    # @param [Array[Object]] args
+    #
+    # @api public
+    def extract_options(args)
+      options = args.last
+      options.respond_to?(:to_hash) ? options.to_hash.dup : {}
+    end
+
+    def extract_options!(args)
+      args.last.respond_to?(:to_hash) ? args.pop : {}
+    end
+
+    # Check if value is nil or an empty string
+    #
+    # @param [Object] value
+    #   the value to check
+    #
+    # @return [Boolean]
+    #
+    # @api public
+    def blank?(value)
+      value.nil? || BLANK_REGEX === value
+    end
+
+    # Deep copy object
+    #
+    # @api public
+    def deep_copy(object)
+      Marshal.load(Marshal.dump(object))
+    end
+  end # Utils
+end # TTY

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

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module TTY
+  class Prompt
+    VERSION = "0.23.1"
+  end # Prompt
+end # TTY