bundler-maglev- 1.0.21

data/lib/bundler/vendor/thor/shell.rb

@@ -0,0 +1,88 @@
+require 'rbconfig'
+
+class Thor
+  module Base
+    # 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 self.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/
+        Thor::Shell::Basic
+      else
+        Thor::Shell::Color
+      end
+    end
+
+    # Sets the shell used in all Thor classes.
+    #
+    def self.shell=(klass)
+      @shell = klass
+    end
+  end
+
+  module Shell
+    SHELL_DELEGATED_METHODS = [:ask, :yes?, :no?, :say, :say_status, :print_table]
+
+    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]
+      self.shell.base ||= self if self.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
+
+    # Sets the shell for this thor class.
+    def shell=(shell)
+      @shell = shell
+    end
+
+    # Common methods that are delegated to the shell.
+    SHELL_DELEGATED_METHODS.each do |method|
+      module_eval <<-METHOD, __FILE__, __LINE__
+        def #{method}(*args)
+          shell.#{method}(*args)
+        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 => self.shell)
+      end
+
+  end
+end

data/lib/bundler/vendor/thor/shell/basic.rb

@@ -0,0 +1,302 @@
+require 'tempfile'
+
+class Thor
+  module Shell
+    class Basic
+      attr_accessor :base, :padding
+
+      # Initialize base and padding to nil.
+      #
+      def initialize #:nodoc:
+        @base, @padding = nil, 0
+      end
+
+      # Mute everything that's inside given block
+      #
+      def mute
+        @mute = true
+        yield
+      ensure
+        @mute = false
+      end
+
+      # Check if base is muted
+      #
+      def mute?
+        @mute
+      end
+
+      # Sets the output padding, not allowing less than zero values.
+      #
+      def padding=(value)
+        @padding = [0, value].max
+      end
+
+      # Ask something to the user and receives a response.
+      #
+      # ==== Example
+      # ask("What is your name?")
+      #
+      def ask(statement, color=nil)
+        say("#{statement} ", color)
+        stdin.gets.strip
+      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)$/))
+        message = message.to_s
+        message = set_color(message, color) if color
+
+        spaces = "  " * padding
+
+        if force_new_line
+          stdout.puts(spaces + message)
+        else
+          stdout.print(spaces + message)
+        end
+        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
+
+        stdout.puts "#{status}#{spaces}#{message}"
+        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))
+      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)
+      end
+
+      # Prints a table.
+      #
+      # ==== Parameters
+      # Array[Array[String, String, ...]]
+      #
+      # ==== Options
+      # ident<Integer>:: Indent the first column by ident value.
+      # colwidth<Integer>:: Force the first column to colwidth spaces wide.
+      #
+      def print_table(table, options={})
+        return if table.empty?
+
+        formats, ident, colwidth = [], options[:ident].to_i, 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"
+        end
+
+        formats[0] = formats[0].insert(0, " " * ident)
+        formats << "%s"
+
+        table.each do |row|
+          sentence = ""
+
+          row.each_with_index do |column, i|
+            sentence << formats[i] % 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
+      # ident<Integer>:: Indent each line of the printed paragraph by ident value.
+      #
+      def print_wrapped(message, options={})
+        ident = options[:ident] || 0
+        width = terminal_width - ident
+        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, " " * ident)
+          end
+          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
+      # 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)
+        return true if @always_force
+        options = block_given? ? "[Ynaqdh]" : "[Ynaqh]"
+
+        while true
+          answer = ask %[Overwrite #{destination}? (enter "h" for help) #{options}]
+
+          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
+          end
+        end
+      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, color, bold=false) #:nodoc:
+        string
+      end
+
+      protected
+
+        def stdout
+          $stdout
+        end
+
+        def stdin
+          $stdin
+        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
+
+        # 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
+
+        # 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)
+          if string.length <= width
+            string
+          else
+            ( string[0, width-3] || "" ) + "..."
+          end
+        end
+
+    end
+  end
+end

data/lib/bundler/vendor/thor/shell/color.rb

@@ -0,0 +1,108 @@
+require 'thor/shell/basic'
+
+class Thor
+  module Shell
+    # Inherit from Thor::Shell::Basic and add set_color behavior. Check
+    # Thor::Shell::Basic to see all available methods.
+    #
+    class Color < Basic
+      # Embed in a String to clear all previous ANSI sequences.
+      CLEAR      = "\e[0m"
+      # The start of an ANSI bold sequence.
+      BOLD       = "\e[1m"
+
+      # Set the terminal's foreground ANSI color to black.
+      BLACK      = "\e[30m"
+      # Set the terminal's foreground ANSI color to red.
+      RED        = "\e[31m"
+      # Set the terminal's foreground ANSI color to green.
+      GREEN      = "\e[32m"
+      # Set the terminal's foreground ANSI color to yellow.
+      YELLOW     = "\e[33m"
+      # Set the terminal's foreground ANSI color to blue.
+      BLUE       = "\e[34m"
+      # Set the terminal's foreground ANSI color to magenta.
+      MAGENTA    = "\e[35m"
+      # Set the terminal's foreground ANSI color to cyan.
+      CYAN       = "\e[36m"
+      # Set the terminal's foreground ANSI color to white.
+      WHITE      = "\e[37m"
+
+      # Set the terminal's background ANSI color to black.
+      ON_BLACK   = "\e[40m"
+      # Set the terminal's background ANSI color to red.
+      ON_RED     = "\e[41m"
+      # Set the terminal's background ANSI color to green.
+      ON_GREEN   = "\e[42m"
+      # Set the terminal's background ANSI color to yellow.
+      ON_YELLOW  = "\e[43m"
+      # Set the terminal's background ANSI color to blue.
+      ON_BLUE    = "\e[44m"
+      # Set the terminal's background ANSI color to magenta.
+      ON_MAGENTA = "\e[45m"
+      # Set the terminal's background ANSI color to cyan.
+      ON_CYAN    = "\e[46m"
+      # Set the terminal's background ANSI color to white.
+      ON_WHITE   = "\e[47m"
+
+      # Set color by using a string or one of the defined constants. If a third
+      # option is set to true, it also adds bold to the string. This is based
+      # 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}"
+      end
+
+      protected
+
+        # 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
+          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
+        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?
+
+          @diff_lcs_loaded = begin
+            require 'diff/lcs'
+            true
+          rescue LoadError
+            false
+          end
+        end
+
+    end
+  end
+end