thor 0.14.6 → 0.19.4

data/lib/thor/shell/basic.rb

@@ -1,14 +1,19 @@
-require 'tempfile'
+require "tempfile"
+require "io/console" if RUBY_VERSION > "1.9.2"
 
 class Thor
   module Shell
     class Basic
-      attr_accessor :base, :padding
+      attr_accessor :base
+      attr_reader   :padding
 
-      # Initialize base and padding to nil.
+      # Initialize base, mute and padding to nil.
       #
       def initialize #:nodoc:
-        @base, @padding = nil, 0
+        @base = nil
+        @mute = false
+        @padding = 0
+        @always_force = false
       end
 
       # Mute everything that's inside given block
@@ -32,14 +37,48 @@ class Thor
         @padding = [0, value].max
       end
 
-      # Ask something to the user and receives a response.
+      # Sets the output padding while executing a block and resets it.
+      #
+      def indent(count = 1)
+        orig_padding = padding
+        self.padding = padding + count
+        yield
+        self.padding = orig_padding
+      end
+
+      # Asks something to the user and receives a response.
+      #
+      # If asked to limit the correct responses, you can pass in an
+      # array of acceptable answers.  If one of those is not supplied,
+      # they will be shown a message stating that one of those answers
+      # must be given and re-asked the question.
+      #
+      # If asking for sensitive information, the :echo option can be set
+      # to false to mask user input from $stdin.
+      #
+      # If the required input is a path, then set the path option to
+      # true. This will enable tab completion for file paths relative
+      # to the current working directory on systems that support
+      # Readline.
       #
       # ==== Example
       # ask("What is your name?")
       #
-      def ask(statement, color=nil)
-        say("#{statement} ", color)
-        $stdin.gets.strip
+      # ask("What is your favorite Neopolitan flavor?", :limited_to => ["strawberry", "chocolate", "vanilla"])
+      #
+      # ask("What is your password?", :echo => false)
+      #
+      # ask("Where should the file be saved?", :path => true)
+      #
+      def ask(statement, *args)
+        options = args.last.is_a?(Hash) ? args.pop : {}
+        color = args.first
+
+        if options[:limited_to]
+          ask_filtered(statement, color, options)
+        else
+          ask_simply(statement, color, options)
+        end
       end
 
       # Say (print) something to the user. If the sentence ends with a whitespace
@@ -49,18 +88,12 @@ class Thor
       # ==== Example
       # say("I know you knew that.")
       #
-      def say(message="", color=nil, force_new_line=(message.to_s !~ /( |\t)$/))
-        message = message.to_s
-        message = set_color(message, color) if color
-
-        spaces = "  " * padding
+      def say(message = "", color = nil, force_new_line = (message.to_s !~ /( |\t)\Z/))
+        buffer = prepare_message(message, *color)
+        buffer << "\n" if force_new_line && !message.to_s.end_with?("\n")
 
-        if force_new_line
-          $stdout.puts(spaces + message)
-        else
-          $stdout.print(spaces + message)
-        end
-        $stdout.flush
+        stdout.print(buffer)
+        stdout.flush
       end
 
       # Say a status with the given color and appends the message. Since this
@@ -68,7 +101,7 @@ class Thor
       # in log_status, avoiding the message from being shown. If a Symbol is
       # given in log_status, it's used as the color.
       #
-      def say_status(status, message, log_status=true)
+      def say_status(status, message, log_status = true)
         return if quiet? || log_status == false
         spaces = "  " * (padding + 1)
         color  = log_status.is_a?(Symbol) ? log_status : :green
@@ -76,22 +109,43 @@ class Thor
         status = status.to_s.rjust(12)
         status = set_color status, color, true if color
 
-        $stdout.puts "#{status}#{spaces}#{message}"
-        $stdout.flush
+        buffer = "#{status}#{spaces}#{message}"
+        buffer << "\n" unless buffer.end_with?("\n")
+
+        stdout.print(buffer)
+        stdout.flush
       end
 
       # Make a question the to user and returns true if the user replies "y" or
       # "yes".
       #
-      def yes?(statement, color=nil)
-        !!(ask(statement, color) =~ is?(:yes))
+      def yes?(statement, color = nil)
+        !!(ask(statement, color, :add_to_history => false) =~ is?(:yes))
       end
 
       # Make a question the to user and returns true if the user replies "n" or
       # "no".
       #
-      def no?(statement, color=nil)
-        !yes?(statement, color)
+      def no?(statement, color = nil)
+        !!(ask(statement, color, :add_to_history => false) =~ is?(:no))
+      end
+
+      # Prints values in columns
+      #
+      # ==== Parameters
+      # Array[String, String, ...]
+      #
+      def print_in_columns(array)
+        return if array.empty?
+        colwidth = (array.map { |el| el.to_s.size }.max || 0) + 2
+        array.each_with_index do |value, index|
+          # Don't output trailing spaces when printing the last column
+          if ((((index + 1) % (terminal_width / colwidth))).zero? && !index.zero?) || index + 1 == array.length
+            stdout.puts value
+          else
+            stdout.printf("%-#{colwidth}s", value)
+          end
+        end
       end
 
       # Prints a table.
@@ -100,35 +154,59 @@ class Thor
       # Array[Array[String, String, ...]]
       #
       # ==== Options
-      # ident<Integer>:: Indent the first column by ident value.
+      # indent<Integer>:: Indent the first column by indent value.
       # colwidth<Integer>:: Force the first column to colwidth spaces wide.
       #
-      def print_table(table, options={})
-        return if table.empty?
+      def print_table(array, options = {}) # rubocop:disable MethodLength
+        return if array.empty?
 
-        formats, ident, colwidth = [], options[:ident].to_i, options[:colwidth]
+        formats = []
+        indent = options[:indent].to_i
+        colwidth = options[:colwidth]
         options[:truncate] = terminal_width if options[:truncate] == true
 
         formats << "%-#{colwidth + 2}s" if colwidth
         start = colwidth ? 1 : 0
 
-        start.upto(table.first.length - 2) do |i|
-          maxima ||= table.max{|a,b| a[i].size <=> b[i].size }[i].size
-          formats << "%-#{maxima + 2}s"
+        colcount = array.max { |a, b| a.size <=> b.size }.size
+
+        maximas = []
+
+        start.upto(colcount - 1) do |index|
+          maxima = array.map { |row| row[index] ? row[index].to_s.size : 0 }.max
+          maximas << maxima
+          formats << if index == colcount - 1
+                       # Don't output 2 trailing spaces when printing the last column
+                       "%-s"
+                     else
+                       "%-#{maxima + 2}s"
+                     end
         end
 
-        formats[0] = formats[0].insert(0, " " * ident)
+        formats[0] = formats[0].insert(0, " " * indent)
         formats << "%s"
 
-        table.each do |row|
+        array.each do |row|
           sentence = ""
 
-          row.each_with_index do |column, i|
-            sentence << formats[i] % column.to_s
+          row.each_with_index do |column, index|
+            maxima = maximas[index]
+
+            f = if column.is_a?(Numeric)
+              if index == row.size - 1
+                # Don't output 2 trailing spaces when printing the last column
+                "%#{maxima}s"
+              else
+                "%#{maxima}s  "
+              end
+            else
+              formats[index]
+            end
+            sentence << f % column.to_s
           end
 
           sentence = truncate(sentence, options[:truncate]) if options[:truncate]
-          $stdout.puts sentence
+          stdout.puts sentence
         end
       end
 
@@ -139,29 +217,27 @@ class Thor
       # String
       #
       # ==== Options
-      # ident<Integer>:: Indent each line of the printed paragraph by ident value.
+      # indent<Integer>:: Indent each line of the printed paragraph by indent value.
       #
-      def print_wrapped(message, options={})
-        ident = options[:ident] || 0
-        width = terminal_width - ident
+      def print_wrapped(message, options = {})
+        indent = options[:indent] || 0
+        width = terminal_width - indent
         paras = message.split("\n\n")
 
         paras.map! do |unwrapped|
-          unwrapped.strip.gsub(/\n/, " ").squeeze(" ").
-          gsub(/.{1,#{width}}(?:\s|\Z)/){($& + 5.chr).
-          gsub(/\n\005/,"\n").gsub(/\005/,"\n")}
+          unwrapped.strip.tr("\n", " ").squeeze(" ").gsub(/.{1,#{width}}(?:\s|\Z)/) { ($& + 5.chr).gsub(/\n\005/, "\n").gsub(/\005/, "\n") }
         end
 
         paras.each do |para|
           para.split("\n").each do |line|
-            $stdout.puts line.insert(0, " " * ident)
+            stdout.puts line.insert(0, " " * indent)
           end
-          $stdout.puts unless para == paras.last
+          stdout.puts unless para == paras.last
         end
       end
 
       # Deals with file collision and returns true if the file should be
-      # overwriten and false otherwise. If a block is given, it uses the block
+      # overwritten and false otherwise. If a block is given, it uses the block
       # response as the content for the diff.
       #
       # ==== Parameters
@@ -172,119 +248,189 @@ class Thor
         return true if @always_force
         options = block_given? ? "[Ynaqdh]" : "[Ynaqh]"
 
-        while true
-          answer = ask %[Overwrite #{destination}? (enter "h" for help) #{options}]
+        loop do
+          answer = ask(
+            %[Overwrite #{destination}? (enter "h" for help) #{options}],
+            :add_to_history => false
+          )
 
           case answer
-            when is?(:yes), is?(:force), ""
-              return true
-            when is?(:no), is?(:skip)
-              return false
-            when is?(:always)
-              return @always_force = true
-            when is?(:quit)
-              say 'Aborting...'
-              raise SystemExit
-            when is?(:diff)
-              show_diff(destination, yield) if block_given?
-              say 'Retrying...'
-            else
-              say file_collision_help
+          when is?(:yes), is?(:force), ""
+            return true
+          when is?(:no), is?(:skip)
+            return false
+          when is?(:always)
+            return @always_force = true
+          when is?(:quit)
+            say "Aborting..."
+            raise SystemExit
+          when is?(:diff)
+            show_diff(destination, yield) if block_given?
+            say "Retrying..."
+          else
+            say file_collision_help
           end
         end
       end
 
+      # This code was copied from Rake, available under MIT-LICENSE
+      # Copyright (c) 2003, 2004 Jim Weirich
+      def terminal_width
+        result = if ENV["THOR_COLUMNS"]
+          ENV["THOR_COLUMNS"].to_i
+        else
+          unix? ? dynamic_width : 80
+        end
+        result < 10 ? 80 : result
+      rescue
+        80
+      end
+
       # Called if something goes wrong during the execution. This is used by Thor
-      # internally and should not be used inside your scripts. If someone went
+      # internally and should not be used inside your scripts. If something went
       # wrong, you can always raise an exception. If you raise a Thor::Error, it
       # will be rescued and wrapped in the method below.
       #
       def error(statement)
-        $stderr.puts statement
+        stderr.puts statement
       end
 
       # Apply color to the given string with optional bold. Disabled in the
       # Thor::Shell::Basic class.
       #
-      def set_color(string, color, bold=false) #:nodoc:
+      def set_color(string, *) #:nodoc:
         string
       end
 
-      protected
+    protected
+
+      def prepare_message(message, *color)
+        spaces = "  " * padding
+        spaces + set_color(message.to_s, *color)
+      end
+
+      def can_display_colors?
+        false
+      end
 
-        def is?(value) #:nodoc:
-          value = value.to_s
+      def lookup_color(color)
+        return color unless color.is_a?(Symbol)
+        self.class.const_get(color.to_s.upcase)
+      end
 
-          if value.size == 1
-            /\A#{value}\z/i
-          else
-            /\A(#{value}|#{value[0,1]})\z/i
-          end
-        end
+      def stdout
+        $stdout
+      end
 
-        def file_collision_help #:nodoc:
-<<HELP
-Y - yes, overwrite
-n - no, do not overwrite
-a - all, overwrite this and all others
-q - quit, abort
-d - diff, show the differences between the old and the new
-h - help, show this help
-HELP
-        end
+      def stderr
+        $stderr
+      end
 
-        def show_diff(destination, content) #:nodoc:
-          diff_cmd = ENV['THOR_DIFF'] || ENV['RAILS_DIFF'] || 'diff -u'
+      def is?(value) #:nodoc:
+        value = value.to_s
 
-          Tempfile.open(File.basename(destination), File.dirname(destination)) do |temp|
-            temp.write content
-            temp.rewind
-            system %(#{diff_cmd} "#{destination}" "#{temp.path}")
-          end
+        if value.size == 1
+          /\A#{value}\z/i
+        else
+          /\A(#{value}|#{value[0, 1]})\z/i
         end
+      end
+
+      def file_collision_help #:nodoc:
+        <<-HELP
+        Y - yes, overwrite
+        n - no, do not overwrite
+        a - all, overwrite this and all others
+        q - quit, abort
+        d - diff, show the differences between the old and the new
+        h - help, show this help
+        HELP
+      end
 
-        def quiet? #:nodoc:
-          mute? || (base && base.options[:quiet])
+      def show_diff(destination, content) #:nodoc:
+        diff_cmd = ENV["THOR_DIFF"] || ENV["RAILS_DIFF"] || "diff -u"
+
+        Tempfile.open(File.basename(destination), File.dirname(destination)) do |temp|
+          temp.write content
+          temp.rewind
+          system %(#{diff_cmd} "#{destination}" "#{temp.path}")
         end
+      end
 
-        # This code was copied from Rake, available under MIT-LICENSE
-        # Copyright (c) 2003, 2004 Jim Weirich
-        def terminal_width
-          if ENV['THOR_COLUMNS']
-            result = ENV['THOR_COLUMNS'].to_i
+      def quiet? #:nodoc:
+        mute? || (base && base.options[:quiet])
+      end
+
+      # Calculate the dynamic width of the terminal
+      def dynamic_width
+        @dynamic_width ||= (dynamic_width_stty.nonzero? || dynamic_width_tput)
+      end
+
+      def dynamic_width_stty
+        `stty size 2>/dev/null`.split[1].to_i
+      end
+
+      def dynamic_width_tput
+        `tput cols 2>/dev/null`.to_i
+      end
+
+      def unix?
+        RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i
+      end
+
+      def truncate(string, width)
+        as_unicode do
+          chars = string.chars.to_a
+          if chars.length <= width
+            chars.join
           else
-            result = unix? ? dynamic_width : 80
+            chars[0, width - 3].join + "..."
           end
-          (result < 10) ? 80 : result
-        rescue
-          80
         end
+      end
 
-        # Calculate the dynamic width of the terminal
-        def dynamic_width
-          @dynamic_width ||= (dynamic_width_stty.nonzero? || dynamic_width_tput)
+      if "".respond_to?(:encode)
+        def as_unicode
+          yield
         end
-
-        def dynamic_width_stty
-          %x{stty size 2>/dev/null}.split[1].to_i
+      else
+        def as_unicode
+          old = $KCODE
+          $KCODE = "U"
+          yield
+        ensure
+          $KCODE = old
         end
+      end
 
-        def dynamic_width_tput
-          %x{tput cols 2>/dev/null}.to_i
-        end
+      def ask_simply(statement, color, options)
+        default = options[:default]
+        message = [statement, ("(#{default})" if default), nil].uniq.join(" ")
+        message = prepare_message(message, *color)
+        result = Thor::LineEditor.readline(message, options)
 
-        def unix?
-          RUBY_PLATFORM =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i
-        end
+        return unless result
 
-        def truncate(string, width)
-          if string.length <= width
-            string
-          else
-            ( string[0, width-3] || "" ) + "..."
-          end
+        result.strip!
+
+        if default && result == ""
+          default
+        else
+          result
         end
+      end
 
+      def ask_filtered(statement, color, options)
+        answer_set = options[:limited_to]
+        correct_answer = nil
+        until correct_answer
+          answers = answer_set.join(", ")
+          answer = ask_simply("#{statement} [#{answers}]", color, options)
+          correct_answer = answer_set.include?(answer) ? answer : nil
+          say("Your response must be one of: [#{answers}]. Please try again.") unless correct_answer
+        end
+        correct_answer
+      end
     end
   end
 end

data/lib/thor/shell/color.rb

@@ -1,4 +1,4 @@
-require 'thor/shell/basic'
+require "thor/shell/basic"
 
 class Thor
   module Shell
@@ -50,59 +50,100 @@ class Thor
       # on Highline implementation and it automatically appends CLEAR to the end
       # of the returned String.
       #
-      def set_color(string, color, bold=false)
-        color = self.class.const_get(color.to_s.upcase) if color.is_a?(Symbol)
-        bold  = bold ? BOLD : ""
-        "#{bold}#{color}#{string}#{CLEAR}"
+      # Pass foreground, background and bold options to this method as
+      # symbols.
+      #
+      # Example:
+      #
+      #   set_color "Hi!", :red, :on_white, :bold
+      #
+      # The available colors are:
+      #
+      #   :bold
+      #   :black
+      #   :red
+      #   :green
+      #   :yellow
+      #   :blue
+      #   :magenta
+      #   :cyan
+      #   :white
+      #   :on_black
+      #   :on_red
+      #   :on_green
+      #   :on_yellow
+      #   :on_blue
+      #   :on_magenta
+      #   :on_cyan
+      #   :on_white
+      def set_color(string, *colors)
+        if colors.compact.empty? || !can_display_colors?
+          string
+        elsif colors.all? { |color| color.is_a?(Symbol) || color.is_a?(String) }
+          ansi_colors = colors.map { |color| lookup_color(color) }
+          "#{ansi_colors.join}#{string}#{CLEAR}"
+        else
+          # The old API was `set_color(color, bold=boolean)`. We
+          # continue to support the old API because you should never
+          # break old APIs unnecessarily :P
+          foreground, bold = colors
+          foreground = self.class.const_get(foreground.to_s.upcase) if foreground.is_a?(Symbol)
+
+          bold       = bold ? BOLD : ""
+          "#{bold}#{foreground}#{string}#{CLEAR}"
+        end
       end
 
-      protected
+    protected
+
+      def can_display_colors?
+        stdout.tty?
+      end
 
-        # Overwrite show_diff to show diff with colors if Diff::LCS is
-        # available.
-        #
-        def show_diff(destination, content) #:nodoc:
-          if diff_lcs_loaded? && ENV['THOR_DIFF'].nil? && ENV['RAILS_DIFF'].nil?
-            actual  = File.binread(destination).to_s.split("\n")
-            content = content.to_s.split("\n")
+      # Overwrite show_diff to show diff with colors if Diff::LCS is
+      # available.
+      #
+      def show_diff(destination, content) #:nodoc:
+        if diff_lcs_loaded? && ENV["THOR_DIFF"].nil? && ENV["RAILS_DIFF"].nil?
+          actual  = File.binread(destination).to_s.split("\n")
+          content = content.to_s.split("\n")
 
-            Diff::LCS.sdiff(actual, content).each do |diff|
-              output_diff_line(diff)
-            end
-          else
-            super
+          Diff::LCS.sdiff(actual, content).each do |diff|
+            output_diff_line(diff)
           end
+        else
+          super
         end
+      end
 
-        def output_diff_line(diff) #:nodoc:
-          case diff.action
-            when '-'
-              say "- #{diff.old_element.chomp}", :red, true
-            when '+'
-              say "+ #{diff.new_element.chomp}", :green, true
-            when '!'
-              say "- #{diff.old_element.chomp}", :red, true
-              say "+ #{diff.new_element.chomp}", :green, true
-            else
-              say "  #{diff.old_element.chomp}", nil, true
-          end
+      def output_diff_line(diff) #:nodoc:
+        case diff.action
+        when "-"
+          say "- #{diff.old_element.chomp}", :red, true
+        when "+"
+          say "+ #{diff.new_element.chomp}", :green, true
+        when "!"
+          say "- #{diff.old_element.chomp}", :red, true
+          say "+ #{diff.new_element.chomp}", :green, true
+        else
+          say "  #{diff.old_element.chomp}", nil, true
         end
+      end
 
-        # Check if Diff::LCS is loaded. If it is, use it to create pretty output
-        # for diff.
-        #
-        def diff_lcs_loaded? #:nodoc:
-          return true  if defined?(Diff::LCS)
-          return @diff_lcs_loaded unless @diff_lcs_loaded.nil?
+      # Check if Diff::LCS is loaded. If it is, use it to create pretty output
+      # for diff.
+      #
+      def diff_lcs_loaded? #:nodoc:
+        return true if defined?(Diff::LCS)
+        return @diff_lcs_loaded unless @diff_lcs_loaded.nil?
 
-          @diff_lcs_loaded = begin
-            require 'diff/lcs'
-            true
-          rescue LoadError
-            false
-          end
+        @diff_lcs_loaded = begin
+          require "diff/lcs"
+          true
+        rescue LoadError
+          false
         end
-
+      end
     end
   end
 end