highline 1.7.10 → 2.0.0.pre.develop.2

data/lib/highline/menu.rb

@@ -1,3 +1,6 @@
+# coding: utf-8
+
+#--
 # menu.rb
 #
 #  Created by Gregory Thomas Brown on 2005-05-10.
@@ -136,7 +139,7 @@ class HighLine
     def choice( name, help = nil, &action )
       @items << [name, action]
 
-      @help[name.to_s.downcase] = help unless help.nil?
+      @help[name.to_s.downcase] = help if help
       update_responses  # rebuild responses based on our settings
     end
 
@@ -154,7 +157,7 @@ class HighLine
     def hidden( name, help = nil, &action )
       @hidden_items << [name, action]
 
-      @help[name.to_s.downcase] = help unless help.nil?
+      @help[name.to_s.downcase] = help if help
     end
 
     #
@@ -235,11 +238,10 @@ class HighLine
     # <tt>:menu_only</tt>::    Just the menu items, followed up by a likely
     #                          short _prompt_.
     # <i>any ERb String</i>::  Will be taken as the literal _layout_.  This
-    #                          String can access <tt>@header</tt>,
-    #                          <tt>@menu</tt> and <tt>@prompt</tt>, but is
-    #                          otherwise evaluated in the typical HighLine
-    #                          context, to provide access to utilities like
-    #                          HighLine.list() primarily.
+    #                          String can access <tt>header</tt>,
+    #                          <tt>menu</tt> and <tt>prompt</tt>, but is
+    #                          otherwise evaluated in the TemplateRenderer
+    #                          context so each method is properly delegated.
     #
     # If set to either <tt>:one_line</tt>, or <tt>:menu_only</tt>, _index_
     # will default to <tt>:none</tt> and _flow_ will default to
@@ -304,7 +306,7 @@ class HighLine
       end
 
       # Run or return it.
-      if not action.nil?
+      if action
         @highline = highline_context
         if @shell
           result = action.call(name, details)
@@ -312,10 +314,8 @@ class HighLine
           result = action.call(name)
         end
         @nil_on_handled ? nil : result
-      elsif action.nil?
-        name
       else
-        nil
+        name
       end
     ensure
       # make sure the hidden items are removed, before we return
@@ -348,19 +348,19 @@ class HighLine
     def to_s(  )
       case @layout
       when :list
-        '<%= if @header.nil? then '' else "#{@header}:\n" end %>' +
-        "<%= list( @menu, #{@flow.inspect},
+        %(<%= header ? "#{header}:\n" : '' %>) +
+        "<%= list( menu, #{@flow.inspect},
                           #{@list_option.inspect} ) %>" +
-        "<%= @prompt %>"
+        "<%= prompt %>"
       when :one_line
-        '<%= if @header.nil? then '' else "#{@header}:  " end %>' +
-        "<%= @prompt %>" +
-        "(<%= list( @menu, #{@flow.inspect},
+        %(<%= header ? "#{header}:  " : '' %>) +
+        "<%= prompt %>" +
+        "(<%= list( menu, #{@flow.inspect},
                            #{@list_option.inspect} ) %>)" +
-        "<%= @prompt[/\s*$/] %>"
+        "<%= prompt[/\s*$/] %>"
       when :menu_only
-        "<%= list( @menu, #{@flow.inspect},
-                          #{@list_option.inspect} ) %><%= @prompt %>"
+        "<%= list( menu, #{@flow.inspect},
+                          #{@list_option.inspect} ) %><%= prompt %>"
       else
         @layout
       end

data/lib/highline/paginator.rb

@@ -0,0 +1,43 @@
+# coding: utf-8
+
+class HighLine
+  class Paginator
+    attr_reader :highline
+
+    def initialize(highline)
+      @highline = highline
+    end
+
+    #
+    # Page print a series of at most _page_at_ lines for _output_.  After each
+    # page is printed, HighLine will pause until the user presses enter/return
+    # then display the next page of data.
+    #
+    # Note that the final page of _output_ is *not* printed, but returned
+    # instead.  This is to support any special handling for the final sequence.
+    #
+    def page_print(text)
+      return text unless highline.page_at
+
+      lines = text.lines.to_a
+      while lines.size > highline.page_at
+        highline.puts lines.slice!(0...highline.page_at).join
+        highline.puts
+        # Return last line if user wants to abort paging
+        return "...\n#{lines.last}" unless continue_paging?
+      end
+      return lines.join
+    end
+
+    #
+    # Ask user if they wish to continue paging output. Allows them to type "q" to
+    # cancel the paging process.
+    #
+    def continue_paging?
+      command = highline.new_scope.ask(
+        "-- press enter/return to continue or q to stop -- "
+      ) { |q| q.character = true }
+      command !~ /\A[qQ]\Z/  # Only continue paging if Q was not hit.
+    end
+  end
+end

data/lib/highline/question.rb

@@ -1,3 +1,6 @@
+# coding: utf-8
+
+#--
 # question.rb
 #
 #  Created by James Edward Gray II on 2005-04-26.
@@ -8,6 +11,7 @@
 require "optparse"
 require "date"
 require "pathname"
+require "highline/question/answer_converter"
 
 class HighLine
   #
@@ -17,23 +21,32 @@ class HighLine
   # process is handled according to the users wishes.
   #
   class Question
-    # An internal HighLine error.  User code does not need to trap this.
-    class NoAutoCompleteMatch < StandardError
-      # do nothing, just creating a unique error type
+    include CustomErrors
+
+    #
+    # If _template_or_question_ is already a Question object just return it.
+    # If not, build it.
+    #
+    def self.build(template_or_question, answer_type = nil, &details)
+      if template_or_question.is_a? Question
+        template_or_question
+      else
+        Question.new(template_or_question, answer_type, &details)
+      end
     end
 
     #
-    # Create an instance of HighLine::Question.  Expects a _question_ to ask
+    # Create an instance of HighLine::Question.  Expects a _template_ to ask
     # (can be <tt>""</tt>) and an _answer_type_ to convert the answer to.
     # The _answer_type_ parameter must be a type recognized by
     # Question.convert(). If given, a block is yielded the new Question
     # object to allow custom initialization.
     #
-    def initialize( question, answer_type )
+    def initialize(template, answer_type)
       # initialize instance data
-      @question    = String(question).dup
+      @template    = template.dup
       @answer_type = answer_type
-      @completion = @answer_type
+      @completion  = @answer_type
 
       @character    = nil
       @limit        = nil
@@ -63,7 +76,11 @@ class HighLine
     end
 
     # The ERb template of the question to be asked.
-    attr_accessor :question
+    attr_accessor :template
+
+    # The answer, set by HighLine#ask
+    attr_accessor :answer
+
     # The type that will be used to convert this answer.
     attr_accessor :answer_type
     # For Auto-completion
@@ -214,12 +231,9 @@ class HighLine
     # Returns the provided _answer_string_ or the default answer for this
     # Question if a default was set and the answer is empty.
     #
-    def answer_or_default( answer_string )
-      if answer_string.length == 0 and not @default.nil?
-        @default
-      else
-        answer_string
-      end
+    def answer_or_default(answer_string)
+      return @default if answer_string.empty? && @default
+      answer_string
     end
 
     #
@@ -230,35 +244,28 @@ class HighLine
     def build_responses(message_source = answer_type, new_hash_wins = false)
       append_default if [::String, Symbol].include? default.class
 
-      choice_error_str_func = lambda do
-        message_source.is_a?(Array) \
-            ? '[' +  message_source.map { |s| "#{s}" }.join(', ') + ']' \
-            : message_source.inspect
-      end
-
       old_hash = @responses
 
-      new_hash = { :ambiguous_completion =>
-                       "Ambiguous choice.  Please choose one of " +
-                       choice_error_str_func.call + '.',
-                     :ask_on_error         =>
-                       "?  ",
-                     :invalid_type         =>
-                       "You must enter a valid #{message_source}.",
-                     :no_completion        =>
-                       "You must choose one of " + choice_error_str_func.call + '.',
-                     :not_in_range         =>
-                       "Your answer isn't within the expected range " +
-                       "(#{expected_range}).",
-                     :mismatch             =>
-                       "Your entries didn't match.",
-                     :not_valid            =>
-                       "Your answer isn't valid (must match " +
-                       "#{@validate.inspect})." }
+      new_hash = build_responses_new_hash(message_source)
 
       @responses = new_hash_wins ? old_hash.merge(new_hash) : new_hash.merge(old_hash)
     end
 
+    def build_responses_new_hash(message_source)
+      { :ambiguous_completion => "Ambiguous choice.  Please choose one of " +
+                                  choice_error_str(message_source) + '.',
+        :ask_on_error         => "?  ",
+        :invalid_type         => "You must enter a valid #{message_source}.",
+        :no_completion        => "You must choose one of " +
+                                  choice_error_str(message_source) + '.',
+        :not_in_range         => "Your answer isn't within the expected range " +
+                                 "(#{expected_range}).",
+        :mismatch             => "Your entries didn't match.",
+        :not_valid            => "Your answer isn't valid (must match " +
+                                 "#{@validate.inspect})." }
+    end
+
+
     #
     # Returns the provided _answer_string_ after changing character case by
     # the rules of this Question.  Valid settings for whitespace are:
@@ -273,7 +280,7 @@ class HighLine
     #
     # An unrecognized choice (like <tt>:none</tt>) is treated as +nil+.
     #
-    def change_case( answer_string )
+    def change_case(answer_string)
       if [:up, :upcase].include?(@case)
         answer_string.upcase
       elsif [:down, :downcase].include?(@case)
@@ -314,46 +321,30 @@ class HighLine
     # This method throws ArgumentError, if the conversion cannot be
     # completed for any reason.
     #
-    def convert( answer_string )
-      if @answer_type.nil?
-        answer_string
-      elsif [::String, HighLine::String].include?(@answer_type)
-        HighLine::String(answer_string)
-      elsif [Float, Integer, String].include?(@answer_type)
-        Kernel.send(@answer_type.to_s.to_sym, answer_string)
-      elsif @answer_type == Symbol
-        answer_string.to_sym
-      elsif @answer_type == Regexp
-        Regexp.new(answer_string)
-      elsif @answer_type.is_a?(Array) or [File, Pathname].include?(@answer_type)
-        # cheating, using OptionParser's Completion module
-        choices = selection
-        choices.extend(OptionParser::Completion)
-        answer = choices.complete(answer_string)
-        if answer.nil?
-          raise NoAutoCompleteMatch
-        end
-        if @answer_type.is_a?(Array)
-          answer.last
-        elsif @answer_type == File
-          File.open(File.join(@directory.to_s, answer.last))
-        else
-          Pathname.new(File.join(@directory.to_s, answer.last))
-        end
-      elsif [Date, DateTime].include?(@answer_type) or @answer_type.is_a?(Class)
-        @answer_type.parse(answer_string)
-      elsif @answer_type.is_a?(Proc)
-        @answer_type[answer_string]
-      end
+    def convert
+      AnswerConverter.new(self).convert
+    end
+
+    def check_range
+      raise NotInRangeQuestionError unless in_range?
+    end
+
+    def choices_complete(answer_string)
+      # cheating, using OptionParser's Completion module
+      choices = selection
+      choices.extend(OptionParser::Completion)
+      answer = choices.complete(answer_string)
+      raise NoAutoCompleteMatch unless answer
+      answer
     end
 
     # Returns an English explanation of the current range settings.
-    def expected_range(  )
+    def expected_range
       expected = [ ]
 
-      expected << "above #{@above}" unless @above.nil?
-      expected << "below #{@below}" unless @below.nil?
-      expected << "included in #{@in.inspect}" unless @in.nil?
+      expected << "above #{@above}" if @above
+      expected << "below #{@below}" if @below
+      expected << "included in #{@in.inspect}" if @in
 
       case expected.size
       when 0 then ""
@@ -364,15 +355,15 @@ class HighLine
     end
 
     # Returns _first_answer_, which will be unset following this call.
-    def first_answer( )
+    def first_answer
       @first_answer
     ensure
       @first_answer = nil
     end
 
     # Returns true if _first_answer_ is set.
-    def first_answer?( )
-      not @first_answer.nil?
+    def first_answer?
+      !!@first_answer
     end
 
     #
@@ -381,10 +372,10 @@ class HighLine
     # _in_ attribute.  Otherwise, +false+ is returned.  Any +nil+ attributes
     # are not checked.
     #
-    def in_range?( answer_object )
-      (@above.nil? or answer_object > @above) and
-      (@below.nil? or answer_object < @below) and
-      (@in.nil? or @in.include?(answer_object))
+    def in_range?
+      (!@above or answer > @above) and
+      (!@below or answer < @below) and
+      (!@in or @in.include?(answer))
     end
 
     #
@@ -406,8 +397,8 @@ class HighLine
     #
     # This process is skipped for single character input.
     #
-    def remove_whitespace( answer_string )
-      if @whitespace.nil?
+    def remove_whitespace(answer_string)
+      if !@whitespace
         answer_string
       elsif [:strip, :chomp].include?(@whitespace)
         answer_string.send(@whitespace)
@@ -423,12 +414,18 @@ class HighLine
       end
     end
 
+    def format_answer(answer_string)
+      answer_string = String(answer_string)
+      answer_string = remove_whitespace(answer_string)
+      change_case(answer_string)
+    end
+
     #
     # Returns an Array of valid answers to this question.  These answers are
     # only known when _answer_type_ is set to an Array of choices, File, or
     # Pathname.  Any other time, this method will return an empty Array.
     #
-    def selection(  )
+    def selection
       if @completion.is_a?(Array)
         @completion
       elsif [File, Pathname].include?(@completion)
@@ -440,9 +437,9 @@ class HighLine
       end
     end
 
-    # Stringifies the question to be asked.
+    # Stringifies the template to be asked.
     def to_s
-      @question
+      @template
     end
 
     #
@@ -452,10 +449,65 @@ class HighLine
     # It's important to realize that an answer is validated after whitespace
     # and case handling.
     #
-    def valid_answer?( answer_string )
-      @validate.nil? or
-      (@validate.is_a?(Regexp) and answer_string =~ @validate) or
-      (@validate.is_a?(Proc)   and @validate[answer_string])
+    def valid_answer?
+      !@validate or
+      (@validate.is_a?(Regexp) and answer =~ @validate) or
+      (@validate.is_a?(Proc)   and @validate[answer])
+    end
+
+    #
+    # Return a line or character of input, as requested for this question.
+    # Character input will be returned as a single character String,
+    # not an Integer.
+    #
+    # This question's _first_answer_ will be returned instead of input, if set.
+    #
+    # Raises EOFError if input is exhausted.
+    #
+    def get_response(highline)
+      return first_answer if first_answer?
+
+      case character
+      when :getc
+        highline.get_response_getc_mode(self)
+      when true
+        highline.get_response_character_mode(self)
+      else
+        highline.get_response_line_mode(self)
+      end
+    end
+
+    def get_response_or_default(highline)
+      self.answer = answer_or_default(get_response(highline))
+    end
+
+    def confirm_question(highline)
+      if confirm == true
+        "Are you sure?  "
+      else
+        # evaluate ERb under initial scope, so it will have
+        # access to question and answer
+        template  = ERB.new(confirm, nil, "%")
+        template_renderer = TemplateRenderer.new(template, self, highline)
+        template_renderer.render
+      end
+    end
+
+    def ask_on_error_msg
+      if responses[:ask_on_error] == :question
+        self
+      elsif responses[:ask_on_error]
+        responses[:ask_on_error]
+      end
+    end
+
+    # readline() needs to handle its own output, but readline only supports
+    # full line reading.  Therefore if question.echo is anything but true,
+    # the prompt will not be issued. And we have to account for that now.
+    # Also, JRuby-1.7's ConsoleReader.readLine() needs to be passed the prompt
+    # to handle line editing properly.
+    def show_question(highline)
+      highline.say(self) unless (@readline && (@echo == true && !@limit))
     end
 
     private
@@ -465,15 +517,23 @@ class HighLine
     # Trailing whitespace is preserved so the function of HighLine.say() is
     # not affected.
     #
-    def append_default(  )
-      if @question =~ /([\t ]+)\Z/
-        @question << "|#{@default}|#{$1}"
-      elsif @question == ""
-        @question << "|#{@default}|  "
-      elsif @question[-1, 1] == "\n"
-        @question[-2, 0] =  "  |#{@default}|"
+    def append_default
+      if @template =~ /([\t ]+)\Z/
+        @template << "|#{@default}|#{$1}"
+      elsif @template == ""
+        @template << "|#{@default}|  "
+      elsif @template[-1, 1] == "\n"
+        @template[-2, 0] =  "  |#{@default}|"
+      else
+        @template << "  |#{@default}|"
+      end
+    end
+
+    def choice_error_str(message_source)
+      if message_source.is_a? Array
+        '[' +  message_source.join(', ') + ']'
       else
-        @question << "  |#{@default}|"
+        message_source.inspect
       end
     end
   end