tty-prompt 0.2.0 → 0.3.0

data/lib/tty/prompt/evaluator.rb

@@ -0,0 +1,29 @@
+# encoding: utf-8
+
+require 'tty/prompt/result'
+
+module TTY
+  class Prompt
+    # Evaluates provided parameters and stops if any of them fails
+    # @api private
+    class Evaluator
+      attr_reader :results
+
+      def initialize(question, &block)
+        @question = question
+        @results = []
+        instance_eval(&block) if block
+      end
+
+      def call(initial)
+        seed = Result::Success.new(@question, initial)
+        results.reduce(seed, &:with)
+      end
+
+      def check(proc = nil, &block)
+        results << (proc || block)
+      end
+      alias_method :<<, :check
+    end # Evaluator
+  end # Prompt
+end # TTY

data/lib/tty/prompt/list.rb

@@ -21,20 +21,18 @@ module TTY
       #   the marker for the selected item
       #
       # @api public
-      def initialize(prompt, options)
-        @prompt = prompt
-        @reader = Reader.new(@prompt)
-        @pastel = Pastel.new
-        @cursor = Cursor.new
-
+      def initialize(prompt, options = {})
+        @prompt       = prompt
         @first_render = true
         @done         = false
         @default      = Array[options.fetch(:default) { 1 }]
         @active       = @default.first
         @choices      = Choices.new
         @color        = options.fetch(:color) { :green }
-        @marker       = options.fetch(:marker) { Codes::ITEM_SELECTED }
+        @marker       = options.fetch(:marker) { Symbols::ITEM_SELECTED }
         @help         = options.fetch(:help) { HELP }
+
+        @prompt.subscribe(self)
       end
 
       # Set marker
@@ -86,6 +84,26 @@ module TTY
         render
       end
 
+      def keyescape(event)
+        exit 130
+      end
+
+      def keyspace(event)
+        @done = true
+      end
+
+      def keyreturn(event)
+        @done = true
+      end
+
+      def keyup(event)
+        @active = (@active == 1) ? @choices.length : @active - 1
+      end
+
+      def keydown(event)
+        @active = (@active == @choices.length) ? 1 : @active + 1
+      end
+
       private
 
       # Setup default option and active selection
@@ -117,16 +135,16 @@ module TTY
       #
       # @api private
       def render
-        @prompt.output.print(@cursor.hide)
+        @prompt.print(@prompt.hide)
         until @done
           render_question
-          process_input
+          @prompt.read_keypress
           refresh
         end
         render_question
         answer = render_answer
       ensure
-        @prompt.output.print(@cursor.show)
+        @prompt.print(@prompt.show)
         answer
       end
 
@@ -139,37 +157,20 @@ module TTY
         @choices[@active - 1].value
       end
 
-      # Process keyboard input
-      #
-      # @api private
-      def process_input
-        chars = @reader.read_keypress
-        case chars
-        when Codes::SIGINT, Codes::ESCAPE
-          exit 130
-        when Codes::RETURN, Codes::SPACE
-          @done = true
-        when Codes::KEY_UP, Codes::CTRL_K, Codes::CTRL_P
-          @active = (@active == 1) ? @choices.length : @active - 1
-        when Codes::KEY_DOWN, Codes::CTRL_J, Codes::CTRL_N
-          @active = (@active == @choices.length) ? 1 : @active + 1
-        end
-      end
-
       # Determine area of the screen to clear
       #
       # @api private
       def refresh
         lines = @question.scan("\n").length + @choices.length + 1
-        @prompt.output.print(@cursor.clear_lines(lines))
+        @prompt.print(@prompt.clear_lines(lines))
       end
 
       # Render question with instructions and menu
       #
       # @api private
       def render_question
-        header = @question + Codes::SPACE + render_header
-        @prompt.output.puts(header)
+        header = "#{@prompt.prefix}#{@question} #{render_header}"
+        @prompt.puts(header)
         @first_render = false
         render_menu unless @done
       end
@@ -182,9 +183,9 @@ module TTY
       def render_header
         if @done
           selected_item = "#{@choices[@active - 1].name}"
-          @pastel.decorate(selected_item, @color)
+          @prompt.decorate(selected_item, @color)
         elsif @first_render
-          @pastel.decorate(@help, :bright_black)
+          @prompt.decorate(@help, :bright_black)
         else
           ''
         end
@@ -196,12 +197,13 @@ module TTY
       def render_menu
         @choices.each_with_index do |choice, index|
           message = if index + 1 == @active
-                      selected = @marker + Codes::SPACE + choice.name
-                      @pastel.decorate("#{selected}", @color)
+                      selected = @marker + Symbols::SPACE + choice.name
+                      @prompt.decorate("#{selected}", @color)
                     else
-                      Codes::SPACE * 2 + choice.name
+                      Symbols::SPACE * 2 + choice.name
                     end
-          @prompt.output.puts(message)
+          newline = (index == @choices.length - 1) ? '' : "\n"
+          @prompt.print(message + newline)
         end
       end
     end # List

data/lib/tty/prompt/mask_question.rb

@@ -0,0 +1,85 @@
+# encoding: utf-8
+
+module TTY
+  class Prompt
+    class MaskQuestion < Question
+      # Create masked question
+      #
+      # @param [Hash] options
+      # @option options [String] :mask
+      #
+      # @api public
+      def initialize(prompt, options = {})
+        super
+        @mask        = options.fetch(:mask) { Symbols::ITEM_SECURE }
+        @done_masked = false
+        @failure     = false
+        @prompt.subscribe(self)
+      end
+
+      # Set character for masking the STDIN input
+      #
+      # @param [String] char
+      #
+      # @return [self]
+      #
+      # @api public
+      def mask(char = (not_set = true))
+        return @mask if not_set
+        @mask = char
+      end
+
+      def keyreturn(event)
+        @done_masked = true
+      end
+
+      def keyenter(event)
+        @done_masked = true
+      end
+
+      def keypress(event)
+        if [:backspace, :delete].include?(event.key.name)
+          @input.chop! unless @input.empty?
+        elsif event.value =~ /^[^\e\n\r]/
+          @input += event.value
+        end
+      end
+
+      # Render question and input replaced with masked character
+      #
+      # @api private
+      def render_question
+        header = "#{prompt.prefix}#{message} "
+        if echo?
+          masked = "#{@mask * "#{@input}".length}"
+          if @done_masked && !@failure
+            masked = @prompt.decorate(masked, @color)
+          end
+          header += masked
+        end
+        @prompt.print(header)
+        @prompt.print("\n") if @done
+      end
+
+      def render_error_or_finish(result)
+        @failure = result.failure?
+        super
+      end
+
+      # Read input from user masked by character
+      #
+      # @private
+      def read_input
+        @done_masked = false
+        @input = ''
+        until @done_masked
+          @prompt.read_keypress(echo?)
+          @prompt.print(@prompt.clear_line)
+          render_question
+        end
+        @prompt.print("\n")
+        @input
+      end
+    end # MaskQuestion
+  end # Prompt
+end # TTY

data/lib/tty/prompt/multi_list.rb

@@ -25,6 +25,18 @@ module TTY
         @default  = options.fetch(:default) { [] }
       end
 
+      # Callback fired when space key is pressed
+      #
+      # @api private
+      def keyspace(event)
+        active_choice = @choices[@active - 1]
+        if @selected.include?(active_choice)
+          @selected.delete(active_choice)
+        else
+          @selected << active_choice
+        end
+      end
+
       private
 
       # Setup default options and active selection
@@ -36,40 +48,16 @@ module TTY
         @active = @default.last unless @selected.empty?
       end
 
-      # Process keyboard input and maintain selected choices
-      #
-      # @api private
-      def process_input
-        chars = @reader.read_keypress
-        case chars
-        when Codes::SIGINT, Codes::ESCAPE
-          exit 130
-        when Codes::RETURN
-          @done = true
-        when Codes::KEY_UP, Codes::CTRL_K, Codes::CTRL_P
-          @active = (@active == 1) ? @choices.length : @active - 1
-        when Codes::KEY_DOWN, Codes::CTRL_J, Codes::CTRL_N
-          @active = (@active == @choices.length) ? 1 : @active + 1
-        when Codes::SPACE
-          active_choice = @choices[@active - 1]
-          if @selected.include?(active_choice)
-            @selected.delete(active_choice)
-          else
-            @selected << active_choice
-          end
-        end
-      end
-
       # Render initial help text and then currently selected choices
       #
       # @api private
       def render_header
         if @done
-          @pastel.decorate(@selected.map(&:name).join(', '), :green)
+          @prompt.decorate(@selected.map(&:name).join(', '), :green)
         elsif @selected.size.nonzero?
           @selected.map(&:name).join(', ')
         elsif @first_render
-          @pastel.decorate(@help, :bright_black)
+          @prompt.decorate(@help, :bright_black)
         else
           ''
         end
@@ -89,15 +77,16 @@ module TTY
       # @api private
       def render_menu
         @choices.each_with_index do |choice, index|
-          indicator = (index + 1 == @active) ?  @marker : Codes::SPACE
-          indicator += Codes::SPACE
+          indicator = (index + 1 == @active) ?  @marker : Symbols::SPACE
+          indicator += Symbols::SPACE
           message = if @selected.include?(choice)
-                      selected = @pastel.decorate(Codes::RADIO_CHECKED, :green)
-                      selected + Codes::SPACE + choice.name
+                      selected = @prompt.decorate(Symbols::RADIO_CHECKED, :green)
+                      selected + Symbols::SPACE + choice.name
                     else
-                      Codes::RADIO_UNCHECKED + Codes::SPACE + choice.name
+                      Symbols::RADIO_UNCHECKED + Symbols::SPACE + choice.name
                     end
-          @prompt.output.puts(indicator + message)
+          newline = (index == @choices.length - 1) ? '' : "\n"
+          @prompt.print(indicator + message + newline)
         end
       end
     end # MultiList

data/lib/tty/prompt/question.rb

@@ -2,61 +2,61 @@
 
 require 'tty/prompt/question/modifier'
 require 'tty/prompt/question/validation'
-require 'tty/prompt/response_delegation'
+require 'tty/prompt/question/checks'
+require 'tty/prompt/converter_dsl'
+require 'tty/prompt/converters'
 
 module TTY
   # A class responsible for shell prompt interactions.
   class Prompt
-    # A class representing a command line question
+    # A class responsible for gathering user input
+    #
+    # @api public
     class Question
-      include ResponseDelegation
+      include Checks
+      include Converters
+
+      BLANK_REGEX = /\A[[:space:]]*\z/o.freeze
+
+      UndefinedSetting = Module.new
 
       # Store question message
       # @api public
       attr_reader :message
 
-      # Store default value.
-      #
-      # @api private
-      attr_reader :default_value
-
-      attr_reader :validation
-
-      # Controls character processing of the answer
-      #
-      # @api public
       attr_reader :modifier
 
-      attr_reader :error
-
-      # Returns character mode
-      #
-      # @api public
-      attr_reader :character
-
-      # @api private
       attr_reader :prompt
 
+      attr_reader :validation
+
       # Initialize a Question
       #
       # @api public
       def initialize(prompt, options = {})
-        @prompt        = prompt || Prompt.new
-        @required      = options.fetch(:required) { false }
-        @echo          = options.fetch(:echo) { true }
-        @raw           = options.fetch(:raw) { false }
-        @mask          = options.fetch(:mask) { false  }
-        @character     = options.fetch(:character) { false }
-        @in            = options.fetch(:in) { false }
-        @modifier      = Modifier.new options.fetch(:modifier) { [] }
-        @validation    = Validation.new(options.fetch(:validation) { nil })
-        @default       = options.fetch(:default) { nil }
-        @error         = false
-        @converter     = Necromancer.new
-        @read          = options.fetch(:read) { nil }
+        @prompt     = prompt
+        @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(:validation) { UndefinedSetting }
+        @read       = options.fetch(:read) { UndefinedSetting }
+        @convert    = options.fetch(:convert) { UndefinedSetting }
+        @color      = options.fetch(:color) { :green }
+        @done       = false
+        @input      = nil
+
+        @evaluator = Evaluator.new(self)
+
+        @evaluator << CheckRequired
+        @evaluator << CheckDefault
+        @evaluator << CheckRange
+        @evaluator << CheckValidation
+        @evaluator << CheckModifier
       end
 
-      # Call the quesiton
+      # Call the question
       #
       # @param [String] message
       #
@@ -64,160 +64,222 @@ module TTY
       #
       # @api public
       def call(message, &block)
+        return if blank?(message)
         @message = message
         block.call(self) if block
-        prompt.output.print("#{prompt.prefix}#{message}")
         render
       end
 
-      # Reader answer and convert to type
+      # Read answer and convert to type
       #
       # @api private
       def render
-        dispatch.read_type(@read)
+        until @done
+          render_question
+          result = process_input
+          errors = result.errors
+          render_error_or_finish(result)
+          refresh(errors.count)
+        end
+        render_question
+        convert_result(result.value)
       end
 
-      # Set default value.
+      # Render question
       #
-      # @api public
-      def default(value)
-        return @default unless value
-        @default = value
+      # @api private
+      def render_question
+        header = "#{prompt.prefix}#{message} "
+        if @convert == :bool && !@done
+          header += @prompt.decorate('(Y/n)', :bright_black) + ' '
+        elsif !echo?
+          header
+        elsif @done
+          header += @prompt.decorate("#{@input}", @color)
+        elsif default?
+          header += @prompt.decorate("(#{default})", :bright_black) + ' '
+        end
+        @prompt.print(header)
+        @prompt.print("\n") if @done
       end
 
-      # Check if default value is set
+      # Decide how to handle input from user
       #
-      # @return [Boolean]
-      #
-      # @api public
-      def default?
-        !!@default
+      # @api private
+      def process_input
+        @input = read_input
+        if blank?(@input)
+          @input = default? ? default : nil
+        end
+        @evaluator.(@input)
       end
 
-      # Ensure that passed argument is present or not
-      #
-      # @return [Boolean]
+      # Process input
       #
-      # @api public
-      def required(value)
-        @required = value
+      # @api private
+      def read_input
+        case @read
+        when :keypress
+          @prompt.read_keypress
+        when :multiline
+          @prompt.read_multiline
+        else
+          @prompt.read_line(echo)
+        end
       end
 
-      # Set validation rule for an argument
+      # Handle error condition
       #
-      # @param [Object] value
+      # @api private
+      def render_error_or_finish(result)
+        if result.failure?
+          result.errors.each do |err|
+            @prompt.print(@prompt.clear_line)
+            @prompt.print(@prompt.decorate('>>', :red) + ' ' + err)
+          end
+          @prompt.print(@prompt.cursor.up(result.errors.count))
+        else
+          @done = true
+          if result.errors.count.nonzero?
+            @prompt.print(@prompt.cursor.down(result.errors.count))
+          end
+        end
+      end
+
+      # Determine area of the screen to clear
       #
-      # @return [Question]
+      # @param [Integer] errors
       #
-      # @api public
-      def validate(value = nil, &block)
-        @validation = Validation.new(value || block)
+      # @api private
+      def refresh(errors = nil)
+        lines = @message.scan("\n").length
+        lines += ((!echo? || errors.nonzero?) ? 1 : 2) # clear user enter
+
+        if errors.nonzero? && @done
+          lines += errors
+        end
+
+        @prompt.print(@prompt.clear_lines(lines))
       end
 
-      # Modify string according to the rule given.
+      # Convert value to expected type
       #
-      # @param [Symbol] rule
+      # @param [Object] value
       #
-      # @api public
-      def modify(*rules)
-        @modifier = Modifier.new(*rules)
+      # @api private
+      def convert_result(value)
+        if convert? & !blank?(value)
+          converter_registry.(@convert, value)
+        else
+          value
+        end
       end
 
-      # Setup behaviour when error(s) occur
+      # Set reader type
       #
       # @api public
-      def on_error(action = nil)
-        @error = action
+      def read(value)
+        @read = value
       end
 
-      # Check if error behaviour is set
+      # Specify answer conversion
       #
       # @api public
-      def error?
-        !!@error
+      def convert(value)
+        @convert = value
       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.
+      # Check if conversion is set
+      #
+      # @return [Boolean]
       #
       # @api public
-      def echo(value = nil)
-        return @echo if value.nil?
-        @echo = value
+      def convert?
+        @convert != UndefinedSetting
       end
 
-      # Chec if echo is set
+      # Set default value.
       #
       # @api public
-      def echo?
-        !!@echo
+      def default(value = (not_set = true))
+        return @default if not_set
+        @default = value
       end
 
-      # Turn raw mode on or off. This enables character-based input.
+      # Check if default value is set
+      #
+      # @return [Boolean]
       #
       # @api public
-      def raw(value = nil)
-        return @raw if value.nil?
-        @raw = value
+      def default?
+        @default != UndefinedSetting
       end
 
-      # Check if raw mode is set
+      # Ensure that passed argument is present or not
+      #
+      # @return [Boolean]
       #
       # @api public
-      def raw?
-        !!@raw
+      def required(value = (not_set = true))
+        return @required if not_set
+        @required = value
       end
+      alias_method :required?, :required
 
-      # Set character for masking the STDIN input
+      # Set validation rule for an argument
       #
-      # @param [String] character
+      # @param [Object] value
       #
-      # @return [self]
+      # @return [Question]
       #
       # @api public
-      def mask(char = nil)
-        return @mask if char.nil?
-        @mask = char
+      def validate(value = nil, &block)
+        @validation = (value || block)
       end
 
-      # Check if character mask is set
+      def validation?
+        @validation != UndefinedSetting
+      end
+
+      # Modify string according to the rule given.
       #
-      # @return [Boolean]
+      # @param [Symbol] rule
       #
       # @api public
-      def mask?
-        !!@mask
+      def modify(*rules)
+        @modifier = rules
       end
 
-      # Set if the input is character based or not
-      #
-      # @param [Boolean] value
-      #
-      # @return [self]
+      # 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 char(value = nil)
-        return @character if value.nil?
-        @character = value
+      def echo(value = nil)
+        return @echo if value.nil?
+        @echo = value
       end
+      alias_method :echo?, :echo
 
-      # Check if character intput is set
-      #
-      # @return [Boolean]
+      # Turn raw mode on or off. This enables character-based input.
       #
       # @api public
-      def character?
-        !!@character
+      def raw(value = nil)
+        return @raw if value.nil?
+        @raw = value
       end
+      alias_method :raw?, :raw
 
-      # Set expect range of values
+      # Set expected range of values
       #
       # @param [String] value
       #
       # @api public
-      def in(value = nil)
-        return @in if value.nil?
-        @in = @converter.convert(value).to(:range, strict: true)
+      def in(value = (not_set = true))
+        if in? && !@in.is_a?(Range)
+          @in = converter_registry.(:range, @in)
+        end
+        return @in if not_set
+        @in = converter_registry.(:range, value)
       end
 
       # Check if range is set
@@ -226,63 +288,23 @@ module TTY
       #
       # @api public
       def in?
-        !!@in
+        @in != UndefinedSetting
       end
 
-      # Check if response matches all the requirements set by the question
-      #
-      # @param [Object] value
-      #
-      # @return [Object]
-      #
-      # @api private
-      def evaluate_response(input)
-        return @default if !input && default?
-        check_required(input)
-        return if input.nil?
-
-        within?(input)
-        validation.(input)
-        modifier.apply_to(input)
-      end
-
-      # Reset question object.
-      #
-      # @api public
-      def clean
-        @message  = nil
-        @default  = nil
-        @required = false
-        @modifier = nil
+      def blank?(value)
+        value.nil? ||
+        value.respond_to?(:empty?) && value.empty? ||
+        BLANK_REGEX === value
       end
 
       def to_s
         "#{message}"
       end
 
+      # String representation of this question
+      # @api public
       def inspect
-        "#<Question @message=#{message}>"
-      end
-
-      private
-
-      # Check if value is present
-      #
-      # @api private
-      def check_required(value)
-        if @required && !default? && value.nil?
-          fail ArgumentRequired, 'No value provided for required'
-        end
-      end
-
-      # Check if value is within expected range
-      #
-      # @api private
-      def within?(value)
-        if in? && value
-          @in.include?(value) || fail(InvalidArgument,
-            "Value #{value} is not included in the range #{@in}")
-        end
+        "#<#{self.class.name} @message=#{message}, @input=#{@input}>"
       end
     end # Question
   end # Prompt