highline 2.0.0.pre.develop.9 → 2.0.0.pre.develop.11

data/lib/highline/question/answer_converter.rb

@@ -1,6 +1,6 @@
 # coding: utf-8
 
-require 'forwardable'
+require "forwardable"
 
 class HighLine
   class Question
@@ -100,4 +100,4 @@ class HighLine
       end
     end
   end
-end
+end

data/lib/highline/question_asker.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 class HighLine
   # Deals with the task of "asking" a question
   class QuestionAsker
@@ -31,13 +33,12 @@ class HighLine
         question.convert
 
         if question.confirm
-          raise NoConfirmationQuestionError unless @highline.send(:confirm, question)
+          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/
@@ -65,29 +66,27 @@ class HighLine
     #
     # @return [Array, Hash] answers
     def gather_answers
-      original_question_template = question.template
       verify_match = question.verify_match
+      answers = []
 
-      begin   # when verify_match is set this loop will repeat until unique_answers == 1
-        question.template = original_question_template
-
+      # when verify_match is set this loop will repeat until unique_answers == 1
+      loop do
         answers = gather_answers_based_on_type
 
-        if verify_match && (@highline.send(:unique_answers, answers).size > 1)
-          explain_error(:mismatch)
-        else
-          verify_match = false
-        end
-      end while verify_match
+        break unless verify_match &&
+                     (@highline.send(:unique_answers, answers).size > 1)
+
+        explain_error(:mismatch)
+      end
 
-      question.verify_match ? @highline.send(:last_answer, answers) : answers
+      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 }
+        (question.gather - 1).times { answers << ask_once }
       end
     end
 
@@ -112,7 +111,6 @@ class HighLine
       end
     end
 
-
     private
 
     ## Delegate to Highline
@@ -133,7 +131,7 @@ class HighLine
     def answer_matches_regex(answer)
       if question.gather.is_a?(::String) || question.gather.is_a?(Symbol)
         answer.to_s == question.gather.to_s
-      else question.gather.is_a?(Regexp)
+      elsif question.gather.is_a?(Regexp)
         answer.to_s =~ question.gather
       end
     end

data/lib/highline/simulate.rb

@@ -10,12 +10,9 @@
 #
 # adapted from https://gist.github.com/194554
 
-
 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.
@@ -28,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
-      if line.length > 0
-        char = line.slice! 0
-        @strings.unshift line
-        char
-      end
+      return if line.empty?
+
+      char = line.slice! 0
+      @strings.unshift line
+      char
     end
 
     # The simulator handles its own EOF
@@ -44,18 +42,18 @@ class HighLine
     end
 
     # A wrapper method that temporarily replaces the Highline
-    # instance in $terminal with an instance of this object
+    # 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

@@ -1,8 +1,8 @@
 # coding: utf-8
 
-require 'highline/wrapper'
-require 'highline/paginator'
-require 'highline/template_renderer'
+require "highline/wrapper"
+require "highline/paginator"
+require "highline/template_renderer"
 
 class HighLine
   # This class handles proper formatting based
@@ -45,6 +45,10 @@ class HighLine
       statement
     end
 
+    def self.const_missing(constant)
+      HighLine.const_get(constant)
+    end
+
     private
 
     def stringfy(template_string)
@@ -52,14 +56,16 @@ class HighLine
     end
 
     def format_statement
-      return template_string unless template_string.length > 0
+      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 = statement.gsub(/\n(?!$)/, "\n#{highline.indentation}") if
+        highline.multi_indent
+
       statement
     end
 
@@ -74,9 +80,5 @@ class HighLine
     def template
       @template ||= ERB.new(template_string, nil, "%")
     end
-
-    def self.const_missing(constant)
-      HighLine.const_get(constant)
-    end
   end
-end
+end

data/lib/highline/string.rb

@@ -3,12 +3,13 @@
 require "highline/string_extensions"
 
 class HighLine
-
   #
-  # HighLine::String is a subclass of String with convenience methods added for colorization.
+  # 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)
+  #   * '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)
@@ -17,19 +18,19 @@ class HighLine
   #                             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:
+  # 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:
+  # 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
+end

data/lib/highline/string_extensions.rb

@@ -1,16 +1,18 @@
 # coding: utf-8
 
-class HighLine
+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)
+  def self.String(s) # rubocop:disable Naming/MethodName
     HighLine::String.new(s)
   end
 
   # HighLine extensions for String class.
   # Included by HighLine::String.
   module StringExtensions
+    STYLE_METHOD_NAME_PATTERN = /^(on_)?rgb_([0-9a-fA-F]{6})$/
+
     # Included hook. Actions to take when being included.
     # @param base [Class, Module] base class
     def self.included(base)
@@ -35,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
@@ -57,19 +59,33 @@ class HighLine
 
         # @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{|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 = 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
@@ -80,28 +96,28 @@ class HighLine
     def self.define_builtin_style_methods(base)
       HighLine::COLORS.each do |color|
         color = color.downcase
-        base.class_eval <<-END
+        base.class_eval <<-METHOD_DEFINITION
           undef :#{color} if method_defined? :#{color}
           def #{color}
             color(:#{color})
           end
-        END
+        METHOD_DEFINITION
 
-        base.class_eval <<-END
+        base.class_eval <<-METHOD_DEFINITION
           undef :on_#{color} if method_defined? :on_#{color}
           def on_#{color}
             on(:#{color})
           end
-        END
+        METHOD_DEFINITION
 
         HighLine::STYLES.each do |style|
           style = style.downcase
-          base.class_eval <<-END
+          base.class_eval <<-METHOD_DEFINITION
             undef :#{style} if method_defined? :#{style}
             def #{style}
               color(:#{style})
             end
-          END
+          METHOD_DEFINITION
         end
       end
     end

data/lib/highline/style.rb

@@ -8,16 +8,14 @@
 #
 # This is Free Software.  See LICENSE and COPYING for details
 
-
-class HighLine
-
+class HighLine #:nodoc:
   # Creates a style using {.find_or_create_style} or
   # {.find_or_create_style_list}
   # @param args [Array<Style, Hash, String>] style properties
   # @return [Style]
   def self.Style(*args)
     args = args.compact.flatten
-    if args.size==1
+    if args.size == 1
       find_or_create_style(args.first)
     else
       find_or_create_style_list(*args)
@@ -33,21 +31,22 @@ class HighLine
     if arg.is_a?(Style)
       Style.list[arg.name] || Style.index(arg)
     elsif arg.is_a?(::String) && arg =~ /^\e\[/ # arg is a code
-      if styles = Style.code_index[arg]
+      styles = Style.code_index[arg]
+      if styles
         styles.first
       else
-        Style.new(:code=>arg)
+        Style.new(code: arg)
       end
-    elsif style = Style.list[arg]
-      style
+    elsif Style.list[arg]
+      Style.list[arg]
     elsif HighLine.color_scheme && HighLine.color_scheme[arg]
       HighLine.color_scheme[arg]
     elsif arg.is_a?(Hash)
       Style.new(arg)
     elsif arg.to_s.downcase =~ /^rgb_([a-f0-9]{6})$/
-      Style.rgb($1)
+      Style.rgb(Regexp.last_match(1))
     elsif arg.to_s.downcase =~ /^on_rgb_([a-f0-9]{6})$/
-      Style.rgb($1).on
+      Style.rgb(Regexp.last_match(1)).on
     else
       raise NameError, "#{arg.inspect} is not a defined Style"
     end
@@ -62,12 +61,11 @@ class HighLine
 
   def self.find_or_create_style_list(*args)
     name = args
-    Style.list[name] || Style.new(:list=>args)
+    Style.list[name] || Style.new(list: args)
   end
 
   # ANSI styles to be used by HighLine.
   class Style
-
     # Index the given style.
     # Uses @code_index (Hash) as repository.
     # @param style [Style]
@@ -77,10 +75,12 @@ class HighLine
         @styles ||= {}
         @styles[style.name] = style
       end
-      if !style.list
+      unless style.list
         @code_index ||= {}
         @code_index[style.code] ||= []
-        @code_index[style.code].reject!{|indexed_style| indexed_style.name == style.name}
+        @code_index[style.code].reject! do |indexed_style|
+          indexed_style.name == style.name
+        end
         @code_index[style.code] << style
       end
       style
@@ -91,9 +91,9 @@ class HighLine
     # @return [void]
     def self.clear_index
       # reset to builtin only styles
-      @styles = list.select { |name, style| style.builtin }
+      @styles = list.select { |_name, style| style.builtin }
       @code_index = {}
-      @styles.each { |name, style| index(style) }
+      @styles.each_value { |style| index(style) }
     end
 
     # Converts all given color codes to hexadecimal and
@@ -106,7 +106,7 @@ class HighLine
     #   HighLine::Style.rgb_hex(9, 10, "11") # => "090a11"
     def self.rgb_hex(*colors)
       colors.map do |color|
-        color.is_a?(Numeric) ? '%02x'%color : color.to_s
+        color.is_a?(Numeric) ? format("%02x", color) : color.to_s
       end.join
     end
 
@@ -117,7 +117,7 @@ class HighLine
     #   HighLine::Style.rgb_parts("090A0B") # => [9, 10, 11]
 
     def self.rgb_parts(hex)
-      hex.scan(/../).map{|part| part.to_i(16)}
+      hex.scan(/../).map { |part| part.to_i(16) }
     end
 
     # Search for or create a new Style from the colors provided.
@@ -132,29 +132,37 @@ class HighLine
     #
     def self.rgb(*colors)
       hex = rgb_hex(*colors)
-      name = ('rgb_' + hex).to_sym
-      if style = list[name]
-        style
-      else
-        parts = rgb_parts(hex)
-        new(:name=>name, :code=>"\e[38;5;#{rgb_number(parts)}m", :rgb=>parts)
-      end
+      name = ("rgb_" + hex).to_sym
+      style = list[name]
+      return style if style
+
+      parts = rgb_parts(hex)
+      new(name: name, code: "\e[38;5;#{rgb_number(parts)}m", rgb: parts)
     end
 
     # Returns the rgb number to be used as escape code on ANSI terminals.
-    # @param parts [Array<Numeric>] three numerical codes for red, green and blue
+    # @param parts [Array<Numeric>] three numerical codes for red, green
+    #   and blue
     # @return [Numeric] to be used as escape code on ANSI terminals
     def self.rgb_number(*parts)
       parts = parts.flatten
-      16 + parts.inject(0) {|kode, part| kode*6 + (part/256.0*6.0).floor}
+      16 + parts.reduce(0) do |kode, part|
+        kode * 6 + (part / 256.0 * 6.0).floor
+      end
     end
 
     # From an ANSI number (color escape code), craft an 'rgb_hex' code of it
     # @param ansi_number [Integer] ANSI escape code
     # @return [String] all color codes joined as {.rgb_hex}
     def self.ansi_rgb_to_hex(ansi_number)
-      raise "Invalid ANSI rgb code #{ansi_number}" unless (16..231).include?(ansi_number)
-      parts = (ansi_number-16).to_s(6).rjust(3,'0').scan(/./).map{|d| (d.to_i*255.0/6.0).ceil}
+      raise "Invalid ANSI rgb code #{ansi_number}" unless
+        (16..231).cover?(ansi_number)
+      parts = (ansi_number - 16).
+              to_s(6).
+              rjust(3, "0").
+              scan(/./).
+              map { |d| (d.to_i * 255.0 / 6.0).ceil }
+
       rgb_hex(*parts)
     end
 
@@ -170,9 +178,9 @@ class HighLine
 
     # Remove any ANSI color escape sequence of the given String.
     # @param string [String]
-    # @return [String] 
+    # @return [String]
     def self.uncolor(string)
-      string.gsub(/\e\[\d+(;\d+)*m/, '')
+      string.gsub(/\e\[\d+(;\d+)*m/, "")
     end
 
     # Style name
@@ -202,7 +210,7 @@ class HighLine
       @builtin = defn[:builtin]
       if @rgb
         hex = self.class.rgb_hex(@rgb)
-        @name ||= 'rgb_' + hex
+        @name ||= "rgb_" + hex
       elsif @list
         @name ||= @list
       end
@@ -228,11 +236,12 @@ class HighLine
       code + string + HighLine::CLEAR
     end
 
-    # @return [String] all codes of the Style list joined together (if a Style list)
+    # @return [String] all codes of the Style list joined together
+    #   (if a Style list)
     # @return [String] the Style code
     def code
       if @list
-        @list.map{|element| HighLine.Style(element).code}.join
+        @list.map { |element| HighLine.Style(element).code }.join
       else
         @code
       end
@@ -257,22 +266,30 @@ class HighLine
     # @param new_name [Symbol]
     # @param options [Hash] Style attributes to be changed
     # @return [Style] new Style with changed attributes
-    def variant(new_name, options={})
+    def variant(new_name, options = {})
       raise "Cannot create a variant of a style list (#{inspect})" if @list
       new_code = options[:code] || code
       if options[:increment]
-        raise "Unexpected code in #{inspect}" unless new_code =~ /^(.*?)(\d+)(.*)/
-        new_code = $1 + ($2.to_i + options[:increment]).to_s + $3
+        raise "Unexpected code in #{inspect}" unless
+          new_code =~ /^(.*?)(\d+)(.*)/
+
+        new_code =
+          Regexp.last_match(1) +
+          (Regexp.last_match(2).to_i +
+          options[:increment]).to_s +
+          Regexp.last_match(3)
       end
       new_rgb = options[:rgb] || @rgb
-      self.class.new(self.to_hash.merge(:name=>new_name, :code=>new_code, :rgb=>new_rgb))
+      self.class.new(to_hash.merge(name: new_name,
+                                   code: new_code,
+                                   rgb: new_rgb))
     end
 
     # Uses the color as background and return a new style.
     # @return [Style]
     def on
-      new_name = ('on_'+@name.to_s).to_sym
-      self.class.list[new_name] ||= variant(new_name, :increment=>10)
+      new_name = ("on_" + @name.to_s).to_sym
+      self.class.list[new_name] ||= variant(new_name, increment: 10)
     end
 
     # @return [Style] a brighter version of this Style
@@ -288,11 +305,17 @@ class HighLine
     private
 
     def create_bright_variant(variant_name)
-      raise "Cannot create a #{name} variant of a style list (#{inspect})" if @list
-      new_name = ("#{variant_name}_"+@name.to_s).to_sym
-      new_rgb = @rgb == [0,0,0] ? [128, 128, 128] : @rgb.map {|color|  color==0 ? 0 : [color+128,255].min }
-
-      find_style(new_name) or variant(new_name, :increment=>60, :rgb=>new_rgb)
+      raise "Cannot create a #{name} variant of a style list (#{inspect})" if
+        @list
+      new_name = ("#{variant_name}_" + @name.to_s).to_sym
+      new_rgb =
+        if @rgb == [0, 0, 0]
+          [128, 128, 128]
+        else
+          @rgb.map { |color| color.zero? ? 0 : [color + 128, 255].min }
+        end
+
+      find_style(new_name) || variant(new_name, increment: 60, rgb: new_rgb)
     end
 
     def find_style(name)