austb-tty-prompt 0.13.0

data/lib/tty/prompt/reader/mode.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+
+require 'io/console'
+
+module TTY
+  class Prompt
+    class Reader
+      class Mode
+        # Initialize a Terminal
+        #
+        # @api public
+        def initialize(input = $stdin)
+          @input = input
+        end
+
+        # Echo given block
+        #
+        # @param [Boolean] is_on
+        #
+        # @api public
+        def echo(is_on = true, &block)
+          if is_on || !@input.tty?
+            yield
+          else
+            @input.noecho(&block)
+          end
+        end
+
+        # Use raw mode in the given block
+        #
+        # @param [Boolean] is_on
+        #
+        # @api public
+        def raw(is_on = true, &block)
+          if is_on && @input.tty?
+            @input.raw(&block)
+          else
+            yield
+          end
+        end
+      end # Mode
+    end # Reader
+  end # Prompt
+end # TTY

data/lib/tty/prompt/reader/win_api.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'fiddle'
+
+module TTY
+  class Prompt
+    class Reader
+      module WinAPI
+        include Fiddle
+
+        Handle = RUBY_VERSION >= "2.0.0" ? Fiddle::Handle : DL::Handle
+
+        CRT_HANDLE = Handle.new("msvcrt") rescue Handle.new("crtdll")
+
+        def getch
+          @@getch ||= Fiddle::Function.new(CRT_HANDLE["_getch"], [], TYPE_INT)
+          @@getch.call
+        end
+        module_function :getch
+
+        def getche
+          @@getche ||= Fiddle::Function.new(CRT_HANDLE["_getche"], [], TYPE_INT)
+          @@getche.call
+        end
+        module_function :getche
+      end # WinAPI
+    end # Reader
+  end # Prompt
+end # TTY

data/lib/tty/prompt/reader/win_console.rb

@@ -0,0 +1,53 @@
+# encoding: utf-8
+
+require_relative 'codes'
+
+module TTY
+  class Prompt
+    class Reader
+      class WinConsole
+        ESC     = "\e".freeze
+        NUL_HEX = "\x00".freeze
+        EXT_HEX = "\xE0".freeze
+
+        # Key codes
+        #
+        # @return [Hash[Symbol]]
+        #
+        # @api public
+        attr_reader :keys
+
+        # Escape codes
+        #
+        # @return [Array[Integer]]
+        #
+        # @api public
+        attr_reader :escape_codes
+
+        def initialize(input)
+          require_relative 'win_api'
+          @input = input
+          @keys = Codes.win_keys
+          @escape_codes = [[NUL_HEX.ord], [ESC.ord], EXT_HEX.bytes.to_a]
+        end
+
+        # Get a character from console with echo
+        #
+        # @param [Hash[Symbol]] options
+        # @option options [Symbol] :echo
+        #   the echo toggle
+        #
+        # @return [String]
+        #
+        # @api private
+        def get_char(options)
+          if options[:raw]
+            WinAPI.getch.chr
+          else
+            options[:echo] ? @input.getc : WinAPI.getch.chr
+          end
+        end
+      end # Console
+    end # Reader
+  end # Prompt
+end # TTY

data/lib/tty/prompt/result.rb

@@ -0,0 +1,42 @@
+# encoding: utf-8
+
+module TTY
+  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 # TTY

data/lib/tty/prompt/slider.rb

@@ -0,0 +1,182 @@
+# encoding: utf-8
+
+require_relative 'symbols'
+
+module TTY
+  # A class responsible for shell prompt interactions.
+  class Prompt
+    # A class responsible for gathering numeric input from range
+    #
+    # @api public
+    class Slider
+      include Symbols
+
+      HELP = '(Use arrow keys, press Enter to select)'.freeze
+
+      # Initailize a Slider
+      #
+      # @api public
+      def initialize(prompt, options = {})
+        @prompt       = prompt
+        @prefix       = options.fetch(:prefix) { @prompt.prefix }
+        @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 }
+        @first_render = true
+        @done         = false
+
+        @prompt.subscribe(self)
+      end
+
+      # Setup initial active position
+      #
+      # @return [Integer]
+      #
+      # @api private
+      def initial
+        if @default.nil?
+          range.size / 2
+        else
+          range.index(@default)
+        end
+      end
+
+      # Range of numbers to render
+      #
+      # @return [Array[Integer]]
+      #
+      # @apip private
+      def range
+        (@min..@max).step(@step).to_a
+      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
+
+      # Call the slider by passing question
+      #
+      # @param [String] question
+      #   the question to ask
+      #
+      # @apu public
+      def call(question, &block)
+        @question = question
+        block.call(self) if block
+        @active = initial
+        render
+      end
+
+      def keyleft(*)
+        @active -= 1 if @active > 0
+      end
+      alias_method :keydown, :keyleft
+
+      def keyright(*)
+        @active += 1 if (@active + @step) < range.size
+      end
+      alias_method :keyup, :keyright
+
+      def keyreturn(*)
+        @done = true
+      end
+      alias_method :keyspace, :keyreturn
+
+      private
+
+      # 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)
+        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]
+      #
+      # @api private
+      def answer
+        range[@active]
+      end
+
+      # Render question with the slider
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_question
+        header = "#{@prefix}#{@question} #{render_header}\n"
+        @first_render = false
+        header << render_slider unless @done
+        header
+      end
+
+      # Render actual answer or help
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_header
+        if @done
+          @prompt.decorate(answer.to_s, @active_color)
+        elsif @first_render
+          @prompt.decorate(HELP, @help_color)
+        end
+      end
+
+      # Render slider representation
+      #
+      # @return [String]
+      #
+      # @api private
+      def render_slider
+        output = ''
+        output << symbols[:pipe]
+        output << symbols[:line] * @active
+        output << @prompt.decorate(symbols[:handle], @active_color)
+        output << symbols[:line] * (range.size - @active - 1)
+        output << symbols[:pipe]
+        output << " #{range[@active]}"
+        output
+      end
+    end # Slider
+  end # Prompt
+end # TTY

data/lib/tty/prompt/statement.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+
+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, options = {})
+        @prompt  = prompt
+        @newline = options.fetch(:newline) { true }
+        @color   = options.fetch(:color) { false }
+      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/tty/prompt/suggestion.rb

@@ -0,0 +1,115 @@
+# encoding: utf-8
+
+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
+        suggestion = ''
+        suggestion << single_text + "\n"
+        suggestion << (' ' * indent + @suggestions.first)
+      end
+
+      # @api private
+      def build_multiple_suggestions
+        suggestion = ''
+        suggestion << plural_text + "\n"
+        suggestion << @suggestions.map do |sugest|
+          ' ' * indent + sugest
+        end.join("\n")
+      end
+    end # Suggestion
+  end # Prompt
+end # TTY