monero_wallet_gen 0.1.0

data/vendor/bundle/ruby/2.3.0/gems/rake-10.5.0/doc/release_notes/rake-10.0.3.rdoc

@@ -0,0 +1,191 @@
+= Rake 10.0.3 Released
+
+  "Jim, when will Rake reach version 1.0?"
+
+Over the past several years I've been asked that question at
+conferences, panels and over twitter. Due to historical reasons (or
+maybe just plain laziness) Rake has (incorrectly) been treating the
+second digit of the version as the major release number. So in my head
+Rake was already at version 9.
+
+Well, it's time to fix things. This next version of Rake drops old,
+crufty, backwards compatibility hacks such as top level constants, DSL
+methods defined in Object and numerous other features that are just no
+longer desired. It's also time to drop the leading zero from the
+version number as well and call this new version of rake what it
+really is: Version 10.
+
+So, welcome to Rake 10.0!
+
+Rake 10 is actually feature identical to the latest version of Rake 9
+(that would be the version spelled 0.9.3), *except* that Rake 10 drops
+all the sundry deprecated features that have accumulated over the years.
+
+If your Rakefile is up to date and current with all the new features
+of Rake 10, you are ready to go. If your Rakefile still uses a few
+deprecated feeatures, feel free to use Rake 9 (0.9.3) with the same
+feature set. Just be aware that future features will be in Rake 10
+family line.
+
+== Changes in Version 10
+
+As mentioned above, there are no new features in Rake 10. However,
+there are a number of features missing:
+
+* Classic namespaces are now gone. Rake is no longer able to reflect
+  the options settings in the global variables ($rakefile, $show_tasks,
+  $show_prereqs, $trace, $dryrun and $silent). The
+  <tt>--classic-namespace</tt> option is no longer supported.
+
+* Global constants are no longer supported. This includes
+  <tt>Task</tt>, <tt>FileTask</tt>, <tt>FileCreationTask</tt> and
+  <tt>RakeApp</tt>). The constant missing hook to warn about using
+  global rake constants has been removed.
+
+* The Rake DSL methods (task, file, directory, etc) are in their own
+  module (Rake::DSL). The stub versions of these methods (that printed
+  warnings) in Object have been removed. However, the DSL methods are
+  added to the top-level <tt>main</tt> object. Since <tt>main</tt> is
+  not in the inheritance tree, the presence of the DSL methods in main
+  should be low impact on other libraries.
+
+  If you want to use the Rake DSL commands from your own code, just
+  include <tt>Rake::DSL</tt> into your own classes and modules.
+
+* The deprecated syntax for task arguments (the one using
+  <tt>:needs</tt>) has been removed.
+
+* The <tt>--reduce-compat</tt> flag has been removed (it's not needed
+  anymore).
+
+* The deprecated <tt>rake/sys.rb</tt> library has been removed.
+
+* The deprecated <tt>rake/rdoctask.rb</tt> library has been removed.
+  RDoc supplies its own rake task now.
+
+* The deprecated <tt>rake/gempackagetask.rb</tt> library has been
+  removed. Gem supplies its own package task now.
+
+There is one small behavioral change:
+
+* Non-file tasks now always report the current time as their time
+  stamp. This is different from the previous behavior where non-file
+  tasks reported current time only if there were no prerequisites, and
+  the max prerequisite timestamp otherwise. This lead to inconsistent
+  and surprising behavior when adding prerequisites to tasks that in
+  turn were prequisites to file tasks. The new behavior is more
+  consistent and predictable.
+
+== Changes (from 0.9.3, 0.9.4, 0.9.5)
+
+Since Rake 10 includes the changes from the last version of Rake 9,
+we'll repeat the changes for versions 0.9.3 through 0.9.5 here.
+
+=== New Features (in 0.9.3)
+
+* Multitask tasks now use a thread pool. Use -j to limit the number of
+  available threads.
+
+* Use -m to turn regular tasks into multitasks (use at your own risk).
+
+* You can now do "Rake.add_rakelib 'dir'" in your Rakefile to
+  programatically add rake task libraries.
+
+* You can specific backtrace suppression patterns (see
+  --supress-backtrace)
+
+* Directory tasks can now take prerequisites and actions
+
+* Use --backtrace to request a full backtrace without the task trace.
+
+* You can say "--backtrace=stdout" and "--trace=stdout" to route trace
+  output to standard output rather than standard error.
+
+* Optional 'phony' target (enable with 'require 'rake/phony'") for
+  special purpose builds.
+
+* Task#clear now clears task comments as well as actions and
+  prerequisites. Task#clear_comment will specifically target comments.
+
+* The --all option will force -T and -D to consider all the tasks,
+  with and without descriptions.
+
+=== Bug Fixes (in 0.9.3)
+
+* Semi-colons in windows rakefile paths now work.
+
+* Improved Control-C support when invoking multiple test suites.
+
+* egrep method now reads files in text mode (better support for
+  Windows)
+
+* Better deprecation line number reporting.
+
+* The -W option now works with all tasks, whether they have a
+  description or not.
+
+* File globs in rake should not be sorted alphabetically, independent
+  of file system and platform.
+
+* Numerous internal improvements.
+
+* Documentation typos and fixes.
+
+=== Bug Fixes (in 0.9.4)
+
+* Exit status with failing tests is not correctly set to non-zero.
+
+* Simplified syntax for phony task (for older versions of RDoc).
+
+* Stand alone FileList usage gets glob function (without loading in
+  extra dependencies)
+
+=== Bug Fixes (in 0.9.5)
+
+* --trace and --backtrace no longer swallow following task names.
+
+== What is Rake
+
+Rake is a build tool similar to the make program in many ways. But
+instead of cryptic make recipes, Rake uses standard Ruby code to
+declare tasks and dependencies. You have the full power of a modern
+scripting language built right into your build tool.
+
+== Availability
+
+The easiest way to get and install rake is via RubyGems ...
+
+  gem install rake    (you may need root/admin privileges)
+
+Otherwise, you can get it from the more traditional places:
+
+Home Page:: http://github.com/jimweirich/rake
+Download::  http://rubyforge.org/project/showfiles.php?group_id=50
+GitHub::    git://github.com/jimweirich/rake.git
+
+== Thanks
+
+As usual, it was input from users that drove a lot of these changes. The
+following people contributed patches, made suggestions or made
+otherwise helpful comments.  Thanks to ...
+
+* Aaron Patterson
+* Dylan Smith
+* Jo Liss
+* Jonas Pfenniger
+* Kazuki Tsujimoto
+* Michael Bishop
+* Michael Elufimov
+* NAKAMURA Usaku
+* Ryan Davis
+* Sam Grönblom
+* Sam Phippen
+* Sergio Wong
+* Tay Ray Chuan
+* grosser
+* quix
+
+Also, many thanks to Eric Hodel for assisting with getting this release
+out the door.
+
+-- Jim Weirich

data/vendor/bundle/ruby/2.3.0/gems/rake-10.5.0/doc/release_notes/rake-10.1.0.rdoc

@@ -0,0 +1,61 @@
+= Rake 10.1.0 Released
+
+== Changes in Version 10.1
+
+=== New Features
+
+* Add support for variable length task argument lists. If more actual
+  arguments are supplied than named arguments, then the extra
+  arguments values will be in args.extras.
+
+* Application name is not displayed in the help banner. (Previously
+  "rake" was hardcoded, now rake-based applications can display their
+  own names).
+
+=== Bug Fixes
+
+Bug fixes include:
+
+* Fix backtrace suppression issues.
+
+* Rules now explicit get task arguments passed to them.
+
+* Rename FileList#exclude? to FileList#exclude_from_list? to avoid
+  conflict with new Rails method.
+
+* Clean / Clobber tasks now report failure to remove files.
+
+* Plus heaps of internal code cleanup.
+
+== What is Rake
+
+Rake is a build tool similar to the make program in many ways. But
+instead of cryptic make recipes, Rake uses standard Ruby code to
+declare tasks and dependencies. You have the full power of a modern
+scripting language built right into your build tool.
+
+== Availability
+
+The easiest way to get and install rake is via RubyGems ...
+
+  gem install rake    (you may need root/admin privileges)
+
+Otherwise, you can get it from the more from GitHub:
+
+GitHub::    git://github.com/jimweirich/rake.git
+
+== Thanks
+
+As usual, it was input from users that drove a lot of these changes.
+The following people contributed patches, made suggestions or made
+otherwise helpful comments. Thanks to ...
+
+* Michael Nikitochkin (general code cleanup)
+* Vipul A M (general code cleanup)
+* Dennis Bell (variable length task argument lists)
+* Jacob Swanner (rules arguments)
+* Rafael Rosa Fu (documentation typo)
+* Stuart Nelson (install.rb fixes)
+* Lee Hambley (application name in help banner)
+
+-- Jim Weirich

data/vendor/bundle/ruby/2.3.0/gems/rake-10.5.0/lib/rake.rb

@@ -0,0 +1,79 @@
+#--
+# Copyright 2003-2010 by Jim Weirich (jim.weirich@gmail.com)
+#
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to
+# deal in the Software without restriction, including without limitation the
+# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
+# sell copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be included in
+# all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
+# IN THE SOFTWARE.
+#++
+
+module Rake
+  VERSION = '10.5.0'
+end
+
+require 'rake/version'
+
+# :stopdoc:
+# TODO: Remove in Rake 11
+RAKEVERSION = Rake::VERSION
+# :startdoc:
+
+require 'rbconfig'
+require 'fileutils'
+require 'singleton'
+require 'monitor'
+require 'optparse'
+require 'ostruct'
+
+require 'rake/ext/module'
+require 'rake/ext/string'
+require 'rake/ext/time'
+
+require 'rake/win32'
+
+require 'rake/linked_list'
+require 'rake/cpu_counter'
+require 'rake/scope'
+require 'rake/task_argument_error'
+require 'rake/rule_recursion_overflow_error'
+require 'rake/rake_module'
+require 'rake/trace_output'
+require 'rake/pseudo_status'
+require 'rake/task_arguments'
+require 'rake/invocation_chain'
+require 'rake/task'
+require 'rake/file_task'
+require 'rake/file_creation_task'
+require 'rake/multi_task'
+require 'rake/dsl_definition'
+require 'rake/file_utils_ext'
+require 'rake/file_list'
+require 'rake/default_loader'
+require 'rake/early_time'
+require 'rake/late_time'
+require 'rake/name_space'
+require 'rake/task_manager'
+require 'rake/application'
+require 'rake/backtrace'
+
+$trace = false
+
+# :stopdoc:
+#
+# Some top level Constants.
+
+FileList = Rake::FileList
+RakeFileUtils = Rake::FileUtilsExt

data/vendor/bundle/ruby/2.3.0/gems/rake-10.5.0/lib/rake/alt_system.rb

@@ -0,0 +1,110 @@
+#
+# Copyright (c) 2008 James M. Lawrence
+#
+# Permission is hereby granted, free of charge, to any person
+# obtaining a copy of this software and associated documentation files
+# (the "Software"), to deal in the Software without restriction,
+# including without limitation the rights to use, copy, modify, merge,
+# publish, distribute, sublicense, and/or sell copies of the Software,
+# and to permit persons to whom the Software is furnished to do so,
+# subject to the following conditions:
+#
+# The above copyright notice and this permission notice shall be
+# included in all copies or substantial portions of the Software.
+#
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+# EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+# MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+# NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
+# BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
+# ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+# CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+#
+
+require 'rbconfig'
+
+##
+# Alternate implementations of system() and backticks `` on Windows
+# for ruby-1.8 and earlier.
+#--
+# TODO: Remove in Rake 11
+
+module Rake::AltSystem # :nodoc: all
+  WINDOWS = RbConfig::CONFIG["host_os"] =~
+    %r!(msdos|mswin|djgpp|mingw|[Ww]indows)!
+
+  class << self
+    def define_module_function(name, &block)
+      define_method(name, &block)
+      module_function(name)
+    end
+  end
+
+  if WINDOWS && RUBY_VERSION < "1.9.0"
+    RUNNABLE_EXTS = %w[com exe bat cmd]
+    RUNNABLE_PATTERN = %r!\.(#{RUNNABLE_EXTS.join('|')})\Z!i
+
+    define_module_function :kernel_system, &Kernel.method(:system)
+    define_module_function :kernel_backticks, &Kernel.method(:'`')
+
+    module_function
+
+    def repair_command(cmd)
+      "call " + (
+        if cmd =~ %r!\A\s*\".*?\"!
+          # already quoted
+          cmd
+        elsif match = cmd.match(%r!\A\s*(\S+)!)
+          if match[1] =~ %r!/!
+            # avoid x/y.bat interpretation as x with option /y
+            %Q!"#{match[1]}"! + match.post_match
+          else
+            # a shell command will fail if quoted
+            cmd
+          end
+        else
+          # empty or whitespace
+          cmd
+        end
+      )
+    end
+
+    def find_runnable(file)
+      if file =~ RUNNABLE_PATTERN
+        file
+      else
+        RUNNABLE_EXTS.each { |ext|
+          test = "#{file}.#{ext}"
+          return test if File.exist?(test)
+        }
+        nil
+      end
+    end
+
+    def system(cmd, *args)
+      repaired = (
+        if args.empty?
+          [repair_command(cmd)]
+        elsif runnable = find_runnable(cmd)
+          [File.expand_path(runnable), *args]
+        else
+          # non-existent file
+          [cmd, *args]
+        end
+      )
+      kernel_system(*repaired)
+    end
+
+    def backticks(cmd)
+      kernel_backticks(repair_command(cmd))
+    end
+
+    define_module_function :'`', &method(:backticks)
+  else
+    # Non-Windows or ruby-1.9+: same as Kernel versions
+    define_module_function :system, &Kernel.method(:system)
+    define_module_function :backticks, &Kernel.method(:'`')
+    define_module_function :'`', &Kernel.method(:'`')
+  end
+end

data/vendor/bundle/ruby/2.3.0/gems/rake-10.5.0/lib/rake/application.rb

@@ -0,0 +1,790 @@
+require 'shellwords'
+require 'optparse'
+
+require 'rake/task_manager'
+require 'rake/file_list'
+require 'rake/thread_pool'
+require 'rake/thread_history_display'
+require 'rake/trace_output'
+require 'rake/win32'
+
+module Rake
+
+  CommandLineOptionError = Class.new(StandardError)
+
+  ##
+  # Rake main application object.  When invoking +rake+ from the
+  # command line, a Rake::Application object is created and run.
+
+  class Application
+    include TaskManager
+    include TraceOutput
+
+    # The name of the application (typically 'rake')
+    attr_reader :name
+
+    # The original directory where rake was invoked.
+    attr_reader :original_dir
+
+    # Name of the actual rakefile used.
+    attr_reader :rakefile
+
+    # Number of columns on the terminal
+    attr_accessor :terminal_columns
+
+    # List of the top level task names (task names from the command line).
+    attr_reader :top_level_tasks
+
+    DEFAULT_RAKEFILES = [
+      'rakefile',
+      'Rakefile',
+      'rakefile.rb',
+      'Rakefile.rb'
+    ].freeze
+
+    # Initialize a Rake::Application object.
+    def initialize
+      super
+      @name = 'rake'
+      @rakefiles = DEFAULT_RAKEFILES.dup
+      @rakefile = nil
+      @pending_imports = []
+      @imported = []
+      @loaders = {}
+      @default_loader = Rake::DefaultLoader.new
+      @original_dir = Dir.pwd
+      @top_level_tasks = []
+      add_loader('rb', DefaultLoader.new)
+      add_loader('rf', DefaultLoader.new)
+      add_loader('rake', DefaultLoader.new)
+      @tty_output = STDOUT.tty?
+      @terminal_columns = ENV['RAKE_COLUMNS'].to_i
+    end
+
+    # Run the Rake application.  The run method performs the following
+    # three steps:
+    #
+    # * Initialize the command line options (+init+).
+    # * Define the tasks (+load_rakefile+).
+    # * Run the top level tasks (+top_level+).
+    #
+    # If you wish to build a custom rake command, you should call
+    # +init+ on your application.  Then define any tasks.  Finally,
+    # call +top_level+ to run your top level tasks.
+    def run
+      standard_exception_handling do
+        init
+        load_rakefile
+        top_level
+      end
+    end
+
+    # Initialize the command line parameters and app name.
+    def init(app_name='rake')
+      standard_exception_handling do
+        @name = app_name
+        args = handle_options
+        collect_command_line_tasks(args)
+      end
+    end
+
+    # Find the rakefile and then load it and any pending imports.
+    def load_rakefile
+      standard_exception_handling do
+        raw_load_rakefile
+      end
+    end
+
+    # Run the top level tasks of a Rake application.
+    def top_level
+      run_with_threads do
+        if options.show_tasks
+          display_tasks_and_comments
+        elsif options.show_prereqs
+          display_prerequisites
+        else
+          top_level_tasks.each { |task_name| invoke_task(task_name) }
+        end
+      end
+    end
+
+    # Run the given block with the thread startup and shutdown.
+    def run_with_threads
+      thread_pool.gather_history if options.job_stats == :history
+
+      yield
+
+      thread_pool.join
+      if options.job_stats
+        stats = thread_pool.statistics
+        puts "Maximum active threads: #{stats[:max_active_threads]} + main"
+        puts "Total threads in play:  #{stats[:total_threads_in_play]} + main"
+      end
+      ThreadHistoryDisplay.new(thread_pool.history).show if
+        options.job_stats == :history
+    end
+
+    # Add a loader to handle imported files ending in the extension
+    # +ext+.
+    def add_loader(ext, loader)
+      ext = ".#{ext}" unless ext =~ /^\./
+      @loaders[ext] = loader
+    end
+
+    # Application options from the command line
+    def options
+      @options ||= OpenStruct.new
+    end
+
+    # Return the thread pool used for multithreaded processing.
+    def thread_pool             # :nodoc:
+      @thread_pool ||= ThreadPool.new(options.thread_pool_size || Rake.suggested_thread_count-1)
+    end
+
+    # internal ----------------------------------------------------------------
+
+    # Invokes a task with arguments that are extracted from +task_string+
+    def invoke_task(task_string) # :nodoc:
+      name, args = parse_task_string(task_string)
+      t = self[name]
+      t.invoke(*args)
+    end
+
+    def parse_task_string(string) # :nodoc:
+      /^([^\[]+)(?:\[(.*)\])$/ =~ string.to_s
+
+      name           = $1
+      remaining_args = $2
+
+      return string, [] unless name
+      return name,   [] if     remaining_args.empty?
+
+      args = []
+
+      begin
+        /((?:[^\\,]|\\.)*?)\s*(?:,\s*(.*))?$/ =~ remaining_args
+
+        remaining_args = $2
+        args << $1.gsub(/\\(.)/, '\1')
+      end while remaining_args
+
+      return name, args
+    end
+
+    # Provide standard exception handling for the given block.
+    def standard_exception_handling # :nodoc:
+      yield
+    rescue SystemExit
+      # Exit silently with current status
+      raise
+    rescue OptionParser::InvalidOption => ex
+      $stderr.puts ex.message
+      exit(false)
+    rescue Exception => ex
+      # Exit with error message
+      display_error_message(ex)
+      exit_because_of_exception(ex)
+    end
+
+    # Exit the program because of an unhandled exception.
+    # (may be overridden by subclasses)
+    def exit_because_of_exception(ex) # :nodoc:
+      exit(false)
+    end
+
+    # Display the error message that caused the exception.
+    def display_error_message(ex) # :nodoc:
+      trace "#{name} aborted!"
+      display_exception_details(ex)
+      trace "Tasks: #{ex.chain}" if has_chain?(ex)
+      trace "(See full trace by running task with --trace)" unless
+         options.backtrace
+    end
+
+    def display_exception_details(ex) # :nodoc:
+      seen = Thread.current[:rake_display_exception_details_seen] ||= []
+      return if seen.include? ex
+      seen << ex
+
+      display_exception_message_details(ex)
+      display_exception_backtrace(ex)
+      display_exception_details(ex.cause) if has_cause?(ex)
+    end
+
+    def has_cause?(ex) # :nodoc:
+      ex.respond_to?(:cause) && ex.cause
+    end
+
+    def display_exception_message_details(ex) # :nodoc:
+      if ex.instance_of?(RuntimeError)
+        trace ex.message
+      else
+        trace "#{ex.class.name}: #{ex.message}"
+      end
+    end
+
+    def display_exception_backtrace(ex) # :nodoc:
+      if options.backtrace
+        trace ex.backtrace.join("\n")
+      else
+        trace Backtrace.collapse(ex.backtrace).join("\n")
+      end
+    end
+
+    # Warn about deprecated usage.
+    #
+    # Example:
+    #    Rake.application.deprecate("import", "Rake.import", caller.first)
+    #
+    def deprecate(old_usage, new_usage, call_site) # :nodoc:
+      unless options.ignore_deprecate
+        $stderr.puts "WARNING: '#{old_usage}' is deprecated.  " +
+          "Please use '#{new_usage}' instead.\n" +
+          "    at #{call_site}"
+      end
+    end
+
+    # Does the exception have a task invocation chain?
+    def has_chain?(exception) # :nodoc:
+      exception.respond_to?(:chain) && exception.chain
+    end
+    private :has_chain?
+
+    # True if one of the files in RAKEFILES is in the current directory.
+    # If a match is found, it is copied into @rakefile.
+    def have_rakefile # :nodoc:
+      @rakefiles.each do |fn|
+        if File.exist?(fn)
+          others = FileList.glob(fn, File::FNM_CASEFOLD)
+          return others.size == 1 ? others.first : fn
+        elsif fn == ''
+          return fn
+        end
+      end
+      return nil
+    end
+
+    # True if we are outputting to TTY, false otherwise
+    def tty_output? # :nodoc:
+      @tty_output
+    end
+
+    # Override the detected TTY output state (mostly for testing)
+    def tty_output=(tty_output_state) # :nodoc:
+      @tty_output = tty_output_state
+    end
+
+    # We will truncate output if we are outputting to a TTY or if we've been
+    # given an explicit column width to honor
+    def truncate_output? # :nodoc:
+      tty_output? || @terminal_columns.nonzero?
+    end
+
+    # Display the tasks and comments.
+    def display_tasks_and_comments # :nodoc:
+      displayable_tasks = tasks.select { |t|
+        (options.show_all_tasks || t.comment) &&
+          t.name =~ options.show_task_pattern
+      }
+      case options.show_tasks
+      when :tasks
+        width = displayable_tasks.map { |t| t.name_with_args.length }.max || 10
+        if truncate_output?
+          max_column = terminal_width - name.size - width - 7
+        else
+          max_column = nil
+        end
+
+        displayable_tasks.each do |t|
+          printf("#{name} %-#{width}s  # %s\n",
+            t.name_with_args,
+            max_column ? truncate(t.comment, max_column) : t.comment)
+        end
+      when :describe
+        displayable_tasks.each do |t|
+          puts "#{name} #{t.name_with_args}"
+          comment = t.full_comment || ""
+          comment.split("\n").each do |line|
+            puts "    #{line}"
+          end
+          puts
+        end
+      when :lines
+        displayable_tasks.each do |t|
+          t.locations.each do |loc|
+            printf "#{name} %-30s %s\n", t.name_with_args, loc
+          end
+        end
+      else
+        fail "Unknown show task mode: '#{options.show_tasks}'"
+      end
+    end
+
+    def terminal_width # :nodoc:
+      if @terminal_columns.nonzero?
+        result = @terminal_columns
+      else
+        result = unix? ? dynamic_width : 80
+      end
+      (result < 10) ? 80 : result
+    rescue
+      80
+    end
+
+    # Calculate the dynamic width of the
+    def dynamic_width # :nodoc:
+      @dynamic_width ||= (dynamic_width_stty.nonzero? || dynamic_width_tput)
+    end
+
+    def dynamic_width_stty # :nodoc:
+      %x{stty size 2>/dev/null}.split[1].to_i
+    end
+
+    def dynamic_width_tput # :nodoc:
+      %x{tput cols 2>/dev/null}.to_i
+    end
+
+    def unix? # :nodoc:
+      RbConfig::CONFIG['host_os'] =~
+        /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i
+    end
+
+    def windows? # :nodoc:
+      Win32.windows?
+    end
+
+    def truncate(string, width) # :nodoc:
+      if string.nil?
+        ""
+      elsif string.length <= width
+        string
+      else
+        (string[0, width - 3] || "") + "..."
+      end
+    end
+
+    # Display the tasks and prerequisites
+    def display_prerequisites # :nodoc:
+      tasks.each do |t|
+        puts "#{name} #{t.name}"
+        t.prerequisites.each { |pre| puts "    #{pre}" }
+      end
+    end
+
+    def trace(*strings) # :nodoc:
+      options.trace_output ||= $stderr
+      trace_on(options.trace_output, *strings)
+    end
+
+    def sort_options(options) # :nodoc:
+      options.sort_by { |opt|
+        opt.select { |o| o =~ /^-/ }.map { |o| o.downcase }.sort.reverse
+      }
+    end
+    private :sort_options
+
+    # A list of all the standard options used in rake, suitable for
+    # passing to OptionParser.
+    def standard_rake_options # :nodoc:
+      sort_options(
+        [
+          ['--all', '-A',
+            "Show all tasks, even uncommented ones (in combination with -T or -D)",
+            lambda { |value|
+              options.show_all_tasks = value
+            }
+          ],
+          ['--backtrace=[OUT]',
+            "Enable full backtrace.  OUT can be stderr (default) or stdout.",
+            lambda { |value|
+              options.backtrace = true
+              select_trace_output(options, 'backtrace', value)
+            }
+          ],
+          ['--build-all', '-B',
+           "Build all prerequisites, including those which are up-to-date.",
+           lambda { |value|
+             options.build_all = true
+           }
+          ],
+          ['--comments',
+            "Show commented tasks only",
+            lambda { |value|
+              options.show_all_tasks = !value
+            }
+          ],
+          ['--describe', '-D [PATTERN]',
+            "Describe the tasks (matching optional PATTERN), then exit.",
+            lambda { |value|
+              select_tasks_to_show(options, :describe, value)
+            }
+          ],
+          ['--dry-run', '-n',
+            "Do a dry run without executing actions.",
+            lambda { |value|
+              Rake.verbose(true)
+              Rake.nowrite(true)
+              options.dryrun = true
+              options.trace = true
+            }
+          ],
+          ['--execute', '-e CODE',
+            "Execute some Ruby code and exit.",
+            lambda { |value|
+              eval(value)
+              exit
+            }
+          ],
+          ['--execute-print', '-p CODE',
+            "Execute some Ruby code, print the result, then exit.",
+            lambda { |value|
+              puts eval(value)
+              exit
+            }
+          ],
+          ['--execute-continue',  '-E CODE',
+            "Execute some Ruby code, " +
+            "then continue with normal task processing.",
+            lambda { |value| eval(value) }
+          ],
+          ['--jobs',  '-j [NUMBER]',
+            "Specifies the maximum number of tasks to execute in parallel. " +
+            "(default is number of CPU cores + 4)",
+            lambda { |value|
+              if value.nil? || value == ''
+                value = FIXNUM_MAX
+              elsif value =~ /^\d+$/
+                value = value.to_i
+              else
+                value = Rake.suggested_thread_count
+              end
+              value = 1 if value < 1
+              options.thread_pool_size = value - 1
+            }
+          ],
+          ['--job-stats [LEVEL]',
+            "Display job statistics. " +
+            "LEVEL=history displays a complete job list",
+            lambda { |value|
+              if value =~ /^history/i
+                options.job_stats = :history
+              else
+                options.job_stats = true
+              end
+            }
+          ],
+          ['--libdir', '-I LIBDIR',
+            "Include LIBDIR in the search path for required modules.",
+            lambda { |value| $:.push(value) }
+          ],
+          ['--multitask', '-m',
+            "Treat all tasks as multitasks.",
+            lambda { |value| options.always_multitask = true }
+          ],
+          ['--no-search', '--nosearch',
+            '-N', "Do not search parent directories for the Rakefile.",
+            lambda { |value| options.nosearch = true }
+          ],
+          ['--prereqs', '-P',
+            "Display the tasks and dependencies, then exit.",
+            lambda { |value| options.show_prereqs = true }
+          ],
+          ['--quiet', '-q',
+            "Do not log messages to standard output.",
+            lambda { |value| Rake.verbose(false) }
+          ],
+          ['--rakefile', '-f [FILENAME]',
+            "Use FILENAME as the rakefile to search for.",
+            lambda { |value|
+              value ||= ''
+              @rakefiles.clear
+              @rakefiles << value
+            }
+          ],
+          ['--rakelibdir', '--rakelib', '-R RAKELIBDIR',
+            "Auto-import any .rake files in RAKELIBDIR. " +
+            "(default is 'rakelib')",
+            lambda { |value|
+              options.rakelib = value.split(File::PATH_SEPARATOR)
+            }
+          ],
+          ['--require', '-r MODULE',
+            "Require MODULE before executing rakefile.",
+            lambda { |value|
+              begin
+                require value
+              rescue LoadError => ex
+                begin
+                  rake_require value
+                rescue LoadError
+                  raise ex
+                end
+              end
+            }
+          ],
+          ['--rules',
+            "Trace the rules resolution.",
+            lambda { |value| options.trace_rules = true }
+          ],
+          ['--silent', '-s',
+            "Like --quiet, but also suppresses the " +
+            "'in directory' announcement.",
+            lambda { |value|
+              Rake.verbose(false)
+              options.silent = true
+            }
+          ],
+          ['--suppress-backtrace PATTERN',
+            "Suppress backtrace lines matching regexp PATTERN. " +
+            "Ignored if --trace is on.",
+            lambda { |value|
+              options.suppress_backtrace_pattern = Regexp.new(value)
+            }
+          ],
+          ['--system',  '-g',
+            "Using system wide (global) rakefiles " +
+            "(usually '~/.rake/*.rake').",
+            lambda { |value| options.load_system = true }
+          ],
+          ['--no-system', '--nosystem', '-G',
+            "Use standard project Rakefile search paths, " +
+            "ignore system wide rakefiles.",
+            lambda { |value| options.ignore_system = true }
+          ],
+          ['--tasks', '-T [PATTERN]',
+            "Display the tasks (matching optional PATTERN) " +
+            "with descriptions, then exit.",
+            lambda { |value|
+              select_tasks_to_show(options, :tasks, value)
+            }
+          ],
+          ['--trace=[OUT]', '-t',
+            "Turn on invoke/execute tracing, enable full backtrace. " +
+            "OUT can be stderr (default) or stdout.",
+            lambda { |value|
+              options.trace = true
+              options.backtrace = true
+              select_trace_output(options, 'trace', value)
+              Rake.verbose(true)
+            }
+          ],
+          ['--verbose', '-v',
+            "Log message to standard output.",
+            lambda { |value| Rake.verbose(true) }
+          ],
+          ['--version', '-V',
+            "Display the program version.",
+            lambda { |value|
+              puts "rake, version #{RAKEVERSION}"
+              exit
+            }
+          ],
+          ['--where', '-W [PATTERN]',
+            "Describe the tasks (matching optional PATTERN), then exit.",
+            lambda { |value|
+              select_tasks_to_show(options, :lines, value)
+              options.show_all_tasks = true
+            }
+          ],
+          ['--no-deprecation-warnings', '-X',
+            "Disable the deprecation warnings.",
+            lambda { |value|
+              options.ignore_deprecate = true
+            }
+          ],
+        ])
+    end
+
+    def select_tasks_to_show(options, show_tasks, value) # :nodoc:
+      options.show_tasks = show_tasks
+      options.show_task_pattern = Regexp.new(value || '')
+      Rake::TaskManager.record_task_metadata = true
+    end
+    private :select_tasks_to_show
+
+    def select_trace_output(options, trace_option, value) # :nodoc:
+      value = value.strip unless value.nil?
+      case value
+      when 'stdout'
+        options.trace_output = $stdout
+      when 'stderr', nil
+        options.trace_output = $stderr
+      else
+        fail CommandLineOptionError,
+          "Unrecognized --#{trace_option} option '#{value}'"
+      end
+    end
+    private :select_trace_output
+
+    # Read and handle the command line options.  Returns the command line
+    # arguments that we didn't understand, which should (in theory) be just
+    # task names and env vars.
+    def handle_options # :nodoc:
+      options.rakelib = ['rakelib']
+      options.trace_output = $stderr
+
+      OptionParser.new do |opts|
+        opts.banner = "#{Rake.application.name} [-f rakefile] {options} targets..."
+        opts.separator ""
+        opts.separator "Options are ..."
+
+        opts.on_tail("-h", "--help", "-H", "Display this help message.") do
+          puts opts
+          exit
+        end
+
+        standard_rake_options.each { |args| opts.on(*args) }
+        opts.environment('RAKEOPT')
+      end.parse(ARGV)
+    end
+
+    # Similar to the regular Ruby +require+ command, but will check
+    # for *.rake files in addition to *.rb files.
+    def rake_require(file_name, paths=$LOAD_PATH, loaded=$") # :nodoc:
+      fn = file_name + ".rake"
+      return false if loaded.include?(fn)
+      paths.each do |path|
+        full_path = File.join(path, fn)
+        if File.exist?(full_path)
+          Rake.load_rakefile(full_path)
+          loaded << fn
+          return true
+        end
+      end
+      fail LoadError, "Can't find #{file_name}"
+    end
+
+    def find_rakefile_location # :nodoc:
+      here = Dir.pwd
+      until (fn = have_rakefile)
+        Dir.chdir("..")
+        return nil if Dir.pwd == here || options.nosearch
+        here = Dir.pwd
+      end
+      [fn, here]
+    ensure
+      Dir.chdir(Rake.original_dir)
+    end
+
+    def print_rakefile_directory(location) # :nodoc:
+      $stderr.puts "(in #{Dir.pwd})" unless
+        options.silent or original_dir == location
+    end
+
+    def raw_load_rakefile # :nodoc:
+      rakefile, location = find_rakefile_location
+      if (! options.ignore_system) &&
+          (options.load_system || rakefile.nil?) &&
+          system_dir && File.directory?(system_dir)
+        print_rakefile_directory(location)
+        glob("#{system_dir}/*.rake") do |name|
+          add_import name
+        end
+      else
+        fail "No Rakefile found (looking for: #{@rakefiles.join(', ')})" if
+          rakefile.nil?
+        @rakefile = rakefile
+        Dir.chdir(location)
+        print_rakefile_directory(location)
+        Rake.load_rakefile(File.expand_path(@rakefile)) if
+          @rakefile && @rakefile != ''
+        options.rakelib.each do |rlib|
+          glob("#{rlib}/*.rake") do |name|
+            add_import name
+          end
+        end
+      end
+      load_imports
+    end
+
+    def glob(path, &block) # :nodoc:
+      FileList.glob(path.gsub("\\", '/')).each(&block)
+    end
+    private :glob
+
+    # The directory path containing the system wide rakefiles.
+    def system_dir # :nodoc:
+      @system_dir ||=
+        begin
+          if ENV['RAKE_SYSTEM']
+            ENV['RAKE_SYSTEM']
+          else
+            standard_system_dir
+          end
+        end
+    end
+
+    # The standard directory containing system wide rake files.
+    if Win32.windows?
+      def standard_system_dir #:nodoc:
+        Win32.win32_system_dir
+      end
+    else
+      def standard_system_dir #:nodoc:
+        File.join(File.expand_path('~'), '.rake')
+      end
+    end
+    private :standard_system_dir
+
+    # Collect the list of tasks on the command line.  If no tasks are
+    # given, return a list containing only the default task.
+    # Environmental assignments are processed at this time as well.
+    #
+    # `args` is the list of arguments to peruse to get the list of tasks.
+    # It should be the command line that was given to rake, less any
+    # recognised command-line options, which OptionParser.parse will
+    # have taken care of already.
+    def collect_command_line_tasks(args) # :nodoc:
+      @top_level_tasks = []
+      args.each do |arg|
+        if arg =~ /^(\w+)=(.*)$/m
+          ENV[$1] = $2
+        else
+          @top_level_tasks << arg unless arg =~ /^-/
+        end
+      end
+      @top_level_tasks.push(default_task_name) if @top_level_tasks.empty?
+    end
+
+    # Default task name ("default").
+    # (May be overridden by subclasses)
+    def default_task_name # :nodoc:
+      "default"
+    end
+
+    # Add a file to the list of files to be imported.
+    def add_import(fn) # :nodoc:
+      @pending_imports << fn
+    end
+
+    # Load the pending list of imported files.
+    def load_imports # :nodoc:
+      while fn = @pending_imports.shift
+        next if @imported.member?(fn)
+        fn_task = lookup(fn) and fn_task.invoke
+        ext = File.extname(fn)
+        loader = @loaders[ext] || @default_loader
+        loader.load(fn)
+        if fn_task = lookup(fn) and fn_task.needed?
+          fn_task.reenable
+          fn_task.invoke
+          loader.load(fn)
+        end
+        @imported << fn
+      end
+    end
+
+    def rakefile_location(backtrace=caller) # :nodoc:
+      backtrace.map { |t| t[/([^:]+):/, 1] }
+
+      re = /^#{@rakefile}$/
+      re = /#{re.source}/i if windows?
+
+      backtrace.find { |str| str =~ re } || ''
+    end
+
+  private
+    FIXNUM_MAX = (2**(0.size * 8 - 2) - 1) # :nodoc:
+
+  end
+end