cvss-suite 1.0.0

data/vendor/cache/ruby/2.2.0/gems/thor-0.19.1/lib/thor/shell.rb

@@ -0,0 +1,81 @@
+require "rbconfig"
+
+class Thor
+  module Base
+    class << self
+      attr_writer :shell
+
+      # Returns the shell used in all Thor classes. If you are in a Unix platform
+      # it will use a colored log, otherwise it will use a basic one without color.
+      #
+      def shell
+        @shell ||= if ENV["THOR_SHELL"] && ENV["THOR_SHELL"].size > 0
+          Thor::Shell.const_get(ENV["THOR_SHELL"])
+        elsif RbConfig::CONFIG["host_os"] =~ /mswin|mingw/ && !ENV["ANSICON"]
+          Thor::Shell::Basic
+        else
+          Thor::Shell::Color
+        end
+      end
+    end
+  end
+
+  module Shell
+    SHELL_DELEGATED_METHODS = [:ask, :error, :set_color, :yes?, :no?, :say, :say_status, :print_in_columns, :print_table, :print_wrapped, :file_collision, :terminal_width]
+    attr_writer :shell
+
+    autoload :Basic, "thor/shell/basic"
+    autoload :Color, "thor/shell/color"
+    autoload :HTML,  "thor/shell/html"
+
+    # Add shell to initialize config values.
+    #
+    # ==== Configuration
+    # shell<Object>:: An instance of the shell to be used.
+    #
+    # ==== Examples
+    #
+    #   class MyScript < Thor
+    #     argument :first, :type => :numeric
+    #   end
+    #
+    #   MyScript.new [1.0], { :foo => :bar }, :shell => Thor::Shell::Basic.new
+    #
+    def initialize(args = [], options = {}, config = {})
+      super
+      self.shell = config[:shell]
+      shell.base ||= self if shell.respond_to?(:base)
+    end
+
+    # Holds the shell for the given Thor instance. If no shell is given,
+    # it gets a default shell from Thor::Base.shell.
+    def shell
+      @shell ||= Thor::Base.shell.new
+    end
+
+    # Common methods that are delegated to the shell.
+    SHELL_DELEGATED_METHODS.each do |method|
+      module_eval <<-METHOD, __FILE__, __LINE__
+        def #{method}(*args,&block)
+          shell.#{method}(*args,&block)
+        end
+      METHOD
+    end
+
+    # Yields the given block with padding.
+    def with_padding
+      shell.padding += 1
+      yield
+    ensure
+      shell.padding -= 1
+    end
+
+  protected
+
+    # Allow shell to be shared between invocations.
+    #
+    def _shared_configuration #:nodoc:
+      super.merge!(:shell => shell)
+    end
+  end
+end

data/vendor/cache/ruby/2.2.0/gems/thor-0.19.1/lib/thor/shell/basic.rb

@@ -0,0 +1,421 @@
+require "tempfile"
+require "io/console" if RUBY_VERSION > "1.9.2"
+
+class Thor
+  module Shell
+    class Basic # rubocop:disable ClassLength
+      attr_accessor :base
+      attr_reader   :padding
+
+      # Initialize base, mute and padding to nil.
+      #
+      def initialize #:nodoc:
+        @base, @mute, @padding, @always_force = nil, false, 0, false
+      end
+
+      # Mute everything that's inside given block
+      #
+      def mute
+        @mute = true
+        yield
+      ensure
+        @mute = false
+      end
+
+      # Check if base is muted
+      #
+      def mute? # rubocop:disable TrivialAccessors
+        @mute
+      end
+
+      # Sets the output padding, not allowing less than zero values.
+      #
+      def padding=(value)
+        @padding = [0, value].max
+      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?")
+      #
+      # 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
+      # or tab character, a new line is not appended (print + flush). Otherwise
+      # are passed straight to puts (behavior got from Highline).
+      #
+      # ==== Example
+      # say("I know you knew that.")
+      #
+      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")
+
+        stdout.print(buffer)
+        stdout.flush
+      end
+
+      # Say a status with the given color and appends the message. Since this
+      # method is used frequently by actions, it allows nil or false to be given
+      # 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)
+        return if quiet? || log_status == false
+        spaces = "  " * (padding + 1)
+        color  = log_status.is_a?(Symbol) ? log_status : :green
+
+        status = status.to_s.rjust(12)
+        status = set_color status, color, true if color
+
+        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, :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)
+        !!(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.
+      #
+      # ==== Parameters
+      # Array[Array[String, String, ...]]
+      #
+      # ==== Options
+      # indent<Integer>:: Indent the first column by indent value.
+      # colwidth<Integer>:: Force the first column to colwidth spaces wide.
+      #
+      def print_table(array, options = {}) # rubocop:disable MethodLength
+        return if array.empty?
+
+        formats, indent, colwidth = [], options[:indent].to_i, options[:colwidth]
+        options[:truncate] = terminal_width if options[:truncate] == true
+
+        formats << "%-#{colwidth + 2}s" if colwidth
+        start = colwidth ? 1 : 0
+
+        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
+          if index == colcount - 1
+            # Don't output 2 trailing spaces when printing the last column
+            formats << "%-s"
+          else
+            formats << "%-#{maxima + 2}s"
+          end
+        end
+
+        formats[0] = formats[0].insert(0, " " * indent)
+        formats << "%s"
+
+        array.each do |row|
+          sentence = ""
+
+          row.each_with_index do |column, index|
+            maxima = maximas[index]
+
+            if column.is_a?(Numeric)
+              if index == row.size - 1
+                # Don't output 2 trailing spaces when printing the last column
+                f = "%#{maxima}s"
+              else
+                f = "%#{maxima}s  "
+              end
+            else
+              f = formats[index]
+            end
+            sentence << f % column.to_s
+          end
+
+          sentence = truncate(sentence, options[:truncate]) if options[:truncate]
+          stdout.puts sentence
+        end
+      end
+
+      # Prints a long string, word-wrapping the text to the current width of the
+      # terminal display. Ideal for printing heredocs.
+      #
+      # ==== Parameters
+      # String
+      #
+      # ==== Options
+      # indent<Integer>:: Indent each line of the printed paragraph by indent value.
+      #
+      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") }
+        end
+
+        paras.each do |para|
+          para.split("\n").each do |line|
+            stdout.puts line.insert(0, " " * indent)
+          end
+          stdout.puts unless para == paras.last
+        end
+      end
+
+      # Deals with file collision and returns true if the file should be
+      # overwritten and false otherwise. If a block is given, it uses the block
+      # response as the content for the diff.
+      #
+      # ==== Parameters
+      # destination<String>:: the destination file to solve conflicts
+      # block<Proc>:: an optional block that returns the value to be used in diff
+      #
+      def file_collision(destination) # rubocop:disable MethodLength
+        return true if @always_force
+        options = block_given? ? "[Ynaqdh]" : "[Ynaqh]"
+
+        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..."
+            fail 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
+        if ENV["THOR_COLUMNS"]
+          result = ENV["THOR_COLUMNS"].to_i
+        else
+          result = 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 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
+      end
+
+      # Apply color to the given string with optional bold. Disabled in the
+      # Thor::Shell::Basic class.
+      #
+      def set_color(string, *args) #:nodoc:
+        string
+      end
+
+    protected
+
+      def prepare_message(message, *color)
+        spaces = "  " * padding
+        spaces + set_color(message.to_s, *color)
+      end
+
+      def can_display_colors?
+        false
+      end
+
+      def lookup_color(color)
+        return color unless color.is_a?(Symbol)
+        self.class.const_get(color.to_s.upcase)
+      end
+
+      def stdout
+        $stdout
+      end
+
+      def stderr
+        $stderr
+      end
+
+      def is?(value) #:nodoc:
+        value = value.to_s
+
+        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 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
+
+      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
+        %x(stty size 2>/dev/null).split[1].to_i
+      end
+
+      def dynamic_width_tput
+        %x(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
+            ( chars[0, width - 3].join) + "..."
+          end
+        end
+      end
+
+      if "".respond_to?(:encode)
+        def as_unicode
+          yield
+        end
+      else
+        def as_unicode
+          old, $KCODE = $KCODE, "U"
+          yield
+        ensure
+          $KCODE = old
+        end
+      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)
+
+        return unless result
+
+        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