highline 1.7.10 → 2.0.3

data/lib/highline/question_asker.rb

@@ -0,0 +1,150 @@
+# encoding: utf-8
+
+class HighLine
+  # Deals with the task of "asking" a question
+  class QuestionAsker
+    # @return [Question] question to be asked
+    attr_reader :question
+
+    include CustomErrors
+
+    # To do its work QuestionAsker needs a Question
+    # to be asked and a HighLine context where to
+    # direct output.
+    #
+    # @param question [Question] question to be asked
+    # @param highline [HighLine] context
+    def initialize(question, highline)
+      @question = question
+      @highline = highline
+    end
+
+    #
+    # Gets just one answer, as opposed to #gather_answers
+    #
+    # @return [String] answer
+    def ask_once
+      question.show_question(@highline)
+
+      begin
+        question.get_response_or_default(@highline)
+        raise NotValidQuestionError unless question.valid_answer?
+
+        question.convert
+
+        if question.confirm
+          confirmation = @highline.send(:confirm, question)
+          raise NoConfirmationQuestionError unless confirmation
+        end
+      rescue ExplainableError => e
+        explain_error(e.explanation_key)
+        retry
+      rescue ArgumentError => error
+        case error.message
+        when /ambiguous/
+          # the assumption here is that OptionParser::Completion#complete
+          # (used for ambiguity resolution) throws exceptions containing
+          # the word 'ambiguous' whenever resolution fails
+          explain_error(:ambiguous_completion)
+          retry
+        when /invalid value for/
+          explain_error(:invalid_type)
+          retry
+        else
+          raise
+        end
+      end
+
+      question.answer
+    end
+
+    ## Multiple questions
+
+    #
+    # Collects an Array/Hash full of answers as described in
+    # HighLine::Question.gather().
+    #
+    # @return [Array, Hash] answers
+    def gather_answers
+      verify_match = question.verify_match
+      answers = []
+
+      # when verify_match is set this loop will repeat until unique_answers == 1
+      loop do
+        answers = gather_answers_based_on_type
+
+        break unless verify_match &&
+                     (@highline.send(:unique_answers, answers).size > 1)
+
+        explain_error(:mismatch)
+      end
+
+      verify_match ? @highline.send(:last_answer, answers) : answers
+    end
+
+    # Gather multiple integer values based on {Question#gather} count
+    # @return [Array] answers
+    def gather_integer
+      gather_with_array do |answers|
+        (question.gather - 1).times { answers << ask_once }
+      end
+    end
+
+    # Gather multiple values until any of them matches the
+    # {Question#gather} Regexp.
+    # @return [Array] answers
+    def gather_regexp
+      gather_with_array do |answers|
+        answers << ask_once until answer_matches_regex(answers.last)
+        answers.pop
+      end
+    end
+
+    # Gather multiple values and store them on a Hash
+    # with keys provided by the Hash on {Question#gather}
+    # @return [Hash]
+    def gather_hash
+      sorted_keys = question.gather.keys.sort_by(&:to_s)
+      sorted_keys.each_with_object({}) do |key, answers|
+        @highline.key = key
+        answers[key]  = ask_once
+      end
+    end
+
+    private
+
+    ## Delegate to Highline
+    def explain_error(explanation_key) # eg: :not_valid, :not_in_range
+      @highline.say(question.final_response(explanation_key))
+      @highline.say(question.ask_on_error_msg)
+    end
+
+    def gather_with_array
+      [].tap do |answers|
+        answers << ask_once
+        question.template = ""
+
+        yield answers
+      end
+    end
+
+    def answer_matches_regex(answer)
+      if question.gather.is_a?(::String) || question.gather.is_a?(Symbol)
+        answer.to_s == question.gather.to_s
+      elsif question.gather.is_a?(Regexp)
+        answer.to_s =~ question.gather
+      end
+    end
+
+    def gather_answers_based_on_type
+      case question.gather
+      when Integer
+        gather_integer
+      when ::String, Symbol, Regexp
+        gather_regexp
+      when Hash
+        gather_hash
+      end
+    end
+  end
+end

data/lib/highline/simulate.rb

@@ -1,3 +1,6 @@
+# coding: utf-8
+
+#--
 # simulate.rb
 #
 #  Created by Andy Rossmeissl on 2012-04-29.
@@ -6,12 +9,13 @@
 #  This is Free Software.  See LICENSE and COPYING for details.
 #
 # adapted from https://gist.github.com/194554
-class HighLine
 
+class HighLine
   # Simulates Highline input for use in tests.
   class Simulate
-
     # Creates a simulator with an array of Strings as a script
+    # @param strings [Array<String>] preloaded string to be used
+    #   as input buffer when simulating.
     def initialize(strings)
       @strings = strings
     end
@@ -21,14 +25,15 @@ class HighLine
       @strings.shift
     end
 
-    # Simulate StringIO#getbyte by shifting a single character off of the next line of the script
+    # Simulate StringIO#getbyte by shifting a single character off of
+    # the next line of the script
     def getbyte
-      line = gets.dup
-      if line.length > 0
-        char = line.slice! 0
-        @strings.unshift line
-        char
-      end
+      line = gets
+      return if line.empty?
+
+      char = line.slice! 0
+      @strings.unshift line
+      char
     end
 
     # The simulator handles its own EOF
@@ -36,13 +41,19 @@ class HighLine
       false
     end
 
-    # A wrapper method that temporarily replaces the Highline instance in $terminal with an instance of this object for the duration of the block
+    # A wrapper method that temporarily replaces the Highline
+    # instance in HighLine.default_instance with an instance of this object
+    # for the duration of the block
+    #
+    # @param strings [String] preloaded string buffer that
+    #   will feed the input operations when simulating.
+
     def self.with(*strings)
-      @input = $terminal.instance_variable_get :@input
-      $terminal.instance_variable_set :@input, new(strings)
+      @input = HighLine.default_instance.instance_variable_get :@input
+      HighLine.default_instance.instance_variable_set :@input, new(strings)
       yield
     ensure
-      $terminal.instance_variable_set :@input, @input
+      HighLine.default_instance.instance_variable_set :@input, @input
     end
   end
 end

data/lib/highline/statement.rb

@@ -0,0 +1,88 @@
+# coding: utf-8
+
+require "highline/wrapper"
+require "highline/paginator"
+require "highline/template_renderer"
+
+class HighLine
+  # This class handles proper formatting based
+  # on a HighLine context, applying wrapping,
+  # pagination, indentation and color rendering
+  # when necessary. It's used by {HighLine#render_statement}
+  # @see HighLine#render_statement
+  class Statement
+    # The source object to be stringfied and formatted.
+    attr_reader :source
+
+    # The HighLine context
+    # @return [HighLine]
+    attr_reader :highline
+
+    # The stringfied source object
+    # @return [String]
+    attr_reader :template_string
+
+    # It needs the input String and the HighLine context
+    # @param source [#to_s]
+    # @param highline [HighLine] context
+    def initialize(source, highline)
+      @highline = highline
+      @source   = source
+      @template_string = stringfy(source)
+    end
+
+    # Returns the formated statement.
+    # Applies wrapping, pagination, indentation and color rendering
+    # based on HighLine instance settings.
+    # @return [String] formated statement
+    def statement
+      @statement ||= format_statement
+    end
+
+    # (see #statement)
+    # Delegates to {#statement}
+    def to_s
+      statement
+    end
+
+    def self.const_missing(constant)
+      HighLine.const_get(constant)
+    end
+
+    private
+
+    def stringfy(template_string)
+      String(template_string || "").dup
+    end
+
+    def format_statement
+      return template_string if template_string.empty?
+
+      statement = render_template
+
+      statement = HighLine::Wrapper.wrap(statement, highline.wrap_at)
+      statement = HighLine::Paginator.new(highline).page_print(statement)
+
+      statement = statement.gsub(/\n(?!$)/, "\n#{highline.indentation}") if
+        highline.multi_indent
+
+      statement
+    end
+
+    def render_template
+      # Assigning to a local var so it may be
+      # used inside instance eval block
+
+      template_renderer = TemplateRenderer.new(template, source, highline)
+      template_renderer.render
+    end
+
+    def template
+      @template ||= if ERB.instance_method(:initialize).parameters.assoc(:key) # Ruby 2.6+
+        ERB.new(template_string, trim_mode: "%")
+      else
+        ERB.new(template_string, nil, "%")
+      end
+    end
+  end
+end

data/lib/highline/string.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+
+require "highline/string_extensions"
+
+class HighLine
+  #
+  # HighLine::String is a subclass of String with convenience methods added
+  # for colorization.
+  #
+  # Available convenience methods include:
+  #   * 'color' method         e.g.  highline_string.color(:bright_blue,
+  #                                                        :underline)
+  #   * colors                 e.g.  highline_string.magenta
+  #   * RGB colors             e.g.  highline_string.rgb_ff6000
+  #                             or   highline_string.rgb(255,96,0)
+  #   * background colors      e.g.  highline_string.on_magenta
+  #   * RGB background colors  e.g.  highline_string.on_rgb_ff6000
+  #                             or   highline_string.on_rgb(255,96,0)
+  #   * styles                 e.g.  highline_string.underline
+  #
+  # Additionally, convenience methods can be chained, for instance the
+  # following are equivalent:
+  #   highline_string.bright_blue.blink.underline
+  #   highline_string.color(:bright_blue, :blink, :underline)
+  #   HighLine.color(highline_string, :bright_blue, :blink, :underline)
+  #
+  # For those less squeamish about possible conflicts, the same convenience
+  # methods can be added to the built-in String class, as follows:
+  #
+  #  require 'highline'
+  #  Highline.colorize_strings
+  #
+  class String < ::String
+    include StringExtensions
+  end
+end

data/lib/highline/string_extensions.rb

@@ -1,61 +1,32 @@
-# Extensions for class String
-#
-# HighLine::String is a subclass of String with convenience methods added for colorization.
-#
-# Available convenience methods include:
-#   * 'color' method         e.g.  highline_string.color(:bright_blue, :underline)
-#   * colors                 e.g.  highline_string.magenta
-#   * RGB colors             e.g.  highline_string.rgb_ff6000
-#                             or   highline_string.rgb(255,96,0)
-#   * background colors      e.g.  highline_string.on_magenta
-#   * RGB background colors  e.g.  highline_string.on_rgb_ff6000
-#                             or   highline_string.on_rgb(255,96,0)
-#   * styles                 e.g.  highline_string.underline
-#
-# Additionally, convenience methods can be chained, for instance the following are equivalent:
-#   highline_string.bright_blue.blink.underline
-#   highline_string.color(:bright_blue, :blink, :underline)
-#   HighLine.color(highline_string, :bright_blue, :blink, :underline)
-#
-# For those less squeamish about possible conflicts, the same convenience methods can be
-# added to the built-in String class, as follows:
-#
-#  require 'highline'
-#  Highline.colorize_strings
-
-class HighLine
-  def self.String(s)
+# coding: utf-8
+
+class HighLine #:nodoc:
+  # Returns a HighLine::String from any given String.
+  # @param s [String]
+  # @return [HighLine::String] from the given string.
+  def self.String(s) # rubocop:disable Naming/MethodName
     HighLine::String.new(s)
   end
 
+  # HighLine extensions for String class.
+  # Included by HighLine::String.
   module StringExtensions
-    def self.included(base)
-      HighLine::COLORS.each do |color|
-        color = color.downcase
-        base.class_eval <<-END
-          undef :#{color} if method_defined? :#{color}
-          def #{color}
-            color(:#{color})
-          end
-        END
+    STYLE_METHOD_NAME_PATTERN = /^(on_)?rgb_([0-9a-fA-F]{6})$/
 
-        base.class_eval <<-END
-          undef :on_#{color} if method_defined? :on_#{color}
-          def on_#{color}
-            on(:#{color})
-          end
-        END
-        HighLine::STYLES.each do |style|
-          style = style.downcase
-          base.class_eval <<-END
-            undef :#{style} if method_defined? :#{style}
-            def #{style}
-              color(:#{style})
-            end
-          END
-        end
-      end
+    # Included hook. Actions to take when being included.
+    # @param base [Class, Module] base class
+    def self.included(base)
+      define_builtin_style_methods(base)
+      define_style_support_methods(base)
+    end
 
+    # At include time, it defines all basic style
+    # support method like #color, #on, #uncolor,
+    # #rgb, #on_rgb and the #method_missing callback
+    # @return [void]
+    # @param base [Class, Module] the base class/module
+    #
+    def self.define_style_support_methods(base)
       base.class_eval do
         undef :color if method_defined? :color
         undef :foreground if method_defined? :foreground
@@ -66,7 +37,7 @@ class HighLine
 
         undef :on if method_defined? :on
         def on(arg)
-          color(('on_' + arg.to_s).to_sym)
+          color(("on_" + arg.to_s).to_sym)
         end
 
         undef :uncolor if method_defined? :uncolor
@@ -76,35 +47,83 @@ class HighLine
 
         undef :rgb if method_defined? :rgb
         def rgb(*colors)
-          color_code = colors.map{|color| color.is_a?(Numeric) ? '%02x'%color : color.to_s}.join
-          raise "Bad RGB color #{colors.inspect}" unless color_code =~ /^[a-fA-F0-9]{6}/
+          color_code = setup_color_code(*colors)
           color("rgb_#{color_code}".to_sym)
         end
 
         undef :on_rgb if method_defined? :on_rgb
         def on_rgb(*colors)
-          color_code = colors.map{|color| color.is_a?(Numeric) ? '%02x'%color : color.to_s}.join
-          raise "Bad RGB color #{colors.inspect}" unless color_code =~ /^[a-fA-F0-9]{6}/
+          color_code = setup_color_code(*colors)
           color("on_rgb_#{color_code}".to_sym)
         end
 
-        # TODO Chain existing method_missing
+        # @todo Chain existing method_missing?
         undef :method_missing if method_defined? :method_missing
-        def method_missing(method, *args, &blk)
-          if method.to_s =~ /^(on_)?rgb_([0-9a-fA-F]{6})$/
+        def method_missing(method, *_args)
+          if method.to_s =~ STYLE_METHOD_NAME_PATTERN
             color(method)
           else
-            raise NoMethodError, "undefined method `#{method}' for #<#{self.class}:#{'%#x'%self.object_id}>"
+            super
           end
         end
+
+        undef :respond_to_missing if method_defined? :respond_to_missing
+        def respond_to_missing?(method_name, include_private = false)
+          method_name.to_s =~ STYLE_METHOD_NAME_PATTERN || super
+        end
+
+        private
+
+        def setup_color_code(*colors)
+          color_code = colors.map do |color|
+            if color.is_a?(Numeric)
+              format("%02x", color)
+            else
+              color.to_s
+            end
+          end.join
+
+          raise "Bad RGB color #{colors.inspect}" unless
+            color_code =~ /^[a-fA-F0-9]{6}/
+
+          color_code
+        end
       end
     end
-  end
 
-  class HighLine::String < ::String
-    include StringExtensions
+    # At include time, it defines all basic builtin styles.
+    # @param base [Class, Module] base Class/Module
+    def self.define_builtin_style_methods(base)
+      HighLine::COLORS.each do |color|
+        color = color.downcase
+        base.class_eval <<-METHOD_DEFINITION
+          undef :#{color} if method_defined? :#{color}
+          def #{color}
+            color(:#{color})
+          end
+        METHOD_DEFINITION
+
+        base.class_eval <<-METHOD_DEFINITION
+          undef :on_#{color} if method_defined? :on_#{color}
+          def on_#{color}
+            on(:#{color})
+          end
+        METHOD_DEFINITION
+
+        HighLine::STYLES.each do |style|
+          style = style.downcase
+          base.class_eval <<-METHOD_DEFINITION
+            undef :#{style} if method_defined? :#{style}
+            def #{style}
+              color(:#{style})
+            end
+          METHOD_DEFINITION
+        end
+      end
+    end
   end
 
+  # Adds color support to the base String class
   def self.colorize_strings
     ::String.send(:include, StringExtensions)
   end