dirty_history 0.5.2 → 0.5.3

data/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/rake-0.8.7/test/rake_test_setup.rb

@@ -1,24 +0,0 @@
-# Common setup for all test files.
-
-begin
-  require 'rubygems'
-  gem 'flexmock'
-rescue LoadError
-  # got no gems
-end
-
-require 'flexmock/test_unit'
-
-if RUBY_VERSION >= "1.9.0"
-  class Test::Unit::TestCase
-#    def passed?
-#      true
-#    end
-  end
-end
-
-module TestMethods
-  def assert_exception(ex, msg=nil, &block)
-    assert_raise(ex, msg, &block)
-  end
-end

data/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/rake-0.8.7/test/reqfile.rb

@@ -1,3 +0,0 @@
-# For --require testing
-
-TESTING_REQUIRE << 1

data/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/rake-0.8.7/test/reqfile2.rb

@@ -1,3 +0,0 @@
-# For --require testing
-
-TESTING_REQUIRE << 2

data/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/rake-0.8.7/test/session_functional.rb

@@ -1,339 +0,0 @@
-#!/usr/bin/env ruby
-
-begin
-  require 'rubygems'
-rescue LoadError => ex
-end
-require 'test/unit'
-require 'fileutils'
-require 'session'
-require 'test/in_environment'
-require 'test/rake_test_setup'
-
-# Version 2.1.9 of session has a bug where the @debug instance
-# variable is not initialized, causing warning messages.  This snippet
-# of code fixes that problem.
-module Session
-  class AbstractSession
-    alias old_initialize initialize
-    def initialize(*args)
-      @debug = nil
-      old_initialize(*args)
-    end
-  end
-end
-
-class FunctionalTest < Test::Unit::TestCase
-  include InEnvironment
-  include TestMethods
-
-  RUBY_COMMAND = 'ruby'
-
-  def setup
-    @rake_path = File.expand_path("bin/rake")
-    lib_path = File.expand_path("lib")
-    @ruby_options = "-I#{lib_path} -I."
-    @verbose = ! ENV['VERBOSE'].nil?
-    if @verbose
-      puts
-      puts
-      puts "--------------------------------------------------------------------"
-      puts name
-      puts "--------------------------------------------------------------------"
-    end
-  end
-
-  def test_rake_default
-    Dir.chdir("test/data/default") do rake end
-    assert_match(/^DEFAULT$/, @out)
-    assert_status
-  end
-
-  def test_rake_error_on_bad_task
-    Dir.chdir("test/data/default") do rake "xyz" end
-    assert_match(/rake aborted/, @err)
-    assert_status(1)
-  end
-
-  def test_env_availabe_at_top_scope
-    Dir.chdir("test/data/default") do rake "TESTTOPSCOPE=1" end
-    assert_match(/^TOPSCOPE$/, @out)
-    assert_status
-  end
-
-  def test_env_availabe_at_task_scope
-    Dir.chdir("test/data/default") do rake "TESTTASKSCOPE=1 task_scope" end
-    assert_match(/^TASKSCOPE$/, @out)
-    assert_status
-  end
-
-  def test_multi_desc
-    in_environment(
-      'RAKE_COLUMNS' => "80",
-      "PWD" => "test/data/multidesc"
-      ) do
-      rake "-T"
-    end
-    assert_match %r{^rake a *# A / A2 *$}, @out
-    assert_match %r{^rake b *# B *$}, @out
-    assert_no_match %r{^rake c}, @out
-    assert_match %r{^rake d *# x{65}\.\.\.$}, @out
-  end
-  
-  def test_long_description
-    in_environment("PWD" => "test/data/multidesc") do
-      rake "--describe"
-    end
-    assert_match %r{^rake a\n *A / A2 *$}m, @out
-    assert_match %r{^rake b\n *B *$}m, @out
-    assert_match %r{^rake d\n *x{80}}m, @out
-    assert_no_match %r{^rake c\n}m, @out
-  end
-
-  def test_rbext
-    in_environment("PWD" => "test/data/rbext") do
-      rake "-N"
-    end
-    assert_match %r{^OK$}, @out
-  end
-
-  def test_system
-    in_environment('RAKE_SYSTEM' => 'test/data/sys') do
-      rake '-g', "sys1"
-    end
-    assert_match %r{^SYS1}, @out
-  end
-
-  def test_system_excludes_rakelib_files_too
-    in_environment('RAKE_SYSTEM' => 'test/data/sys') do
-      rake '-g', "sys1", '-T', 'extra'
-    end
-    assert_no_match %r{extra:extra}, @out
-  end
-
-  def test_by_default_rakelib_files_are_include
-    in_environment('RAKE_SYSTEM' => 'test/data/sys') do
-      rake '-T', 'extra'
-    end
-    assert_match %r{extra:extra}, @out
-  end
-
-  def test_implicit_system
-    in_environment('RAKE_SYSTEM' => File.expand_path('test/data/sys'), "PWD" => "/") do
-      rake "sys1", "--trace"
-    end
-    assert_match %r{^SYS1}, @out
-  end
-
-  def test_no_system
-    in_environment('RAKE_SYSTEM' => 'test/data/sys') do
-      rake '-G', "sys1"
-    end
-    assert_match %r{^Don't know how to build task}, @err # emacs wart: '
-  end
-
-  def test_nosearch_with_rakefile_uses_local_rakefile
-    in_environment("PWD" => "test/data/default") do
-      rake "--nosearch"
-    end
-    assert_match %r{^DEFAULT}, @out
-  end
-
-  def test_nosearch_without_rakefile_finds_system
-    in_environment(
-      "PWD" => "test/data/nosearch",
-      "RAKE_SYSTEM" => File.expand_path("test/data/sys")
-      ) do
-      rake "--nosearch", "sys1"
-    end
-    assert_match %r{^SYS1}, @out
-  end
-
-  def test_nosearch_without_rakefile_and_no_system_fails
-    in_environment("PWD" => "test/data/nosearch", "RAKE_SYSTEM" => "not_exist") do
-      rake "--nosearch"
-    end
-    assert_match %r{^No Rakefile found}, @err
-  end
-
-  def test_dry_run
-    in_environment("PWD" => "test/data/default") do rake "-n", "other" end
-    assert_match %r{Execute \(dry run\) default}, @out
-    assert_match %r{Execute \(dry run\) other}, @out
-    assert_no_match %r{DEFAULT}, @out
-    assert_no_match %r{OTHER}, @out
-  end
-
-  # Test for the trace/dry_run bug found by Brian Chandler
-  def test_dry_run_bug
-    in_environment("PWD" => "test/data/dryrun") do
-      rake
-    end
-    FileUtils.rm_f "test/data/dryrun/temp_one"
-    in_environment("PWD" => "test/data/dryrun") do
-      rake "--dry-run"
-    end
-    assert_no_match(/No such file/, @out)
-    assert_status
-  end
-
-  # Test for the trace/dry_run bug found by Brian Chandler
-  def test_trace_bug
-    in_environment("PWD" => "test/data/dryrun") do
-      rake
-    end
-    FileUtils.rm_f "test/data/dryrun/temp_one"
-    in_environment("PWD" => "test/data/dryrun") do
-      rake "--trace"
-    end
-    assert_no_match(/No such file/, @out)
-    assert_status
-  end
-
-  def test_imports
-    open("test/data/imports/static_deps", "w") do |f|
-      f.puts 'puts "STATIC"'
-    end
-    FileUtils.rm_f "test/data/imports/dynamic_deps"
-    in_environment("PWD" => "test/data/imports") do
-      rake
-    end
-    assert File.exist?("test/data/imports/dynamic_deps"),
-      "'dynamic_deps' file should exist"
-    assert_match(/^FIRST$\s+^DYNAMIC$\s+^STATIC$\s+^OTHER$/, @out)
-    assert_status
-    FileUtils.rm_f "test/data/imports/dynamic_deps"
-    FileUtils.rm_f "test/data/imports/static_deps"
-  end
-
-  def test_rules_chaining_to_file_task
-    remove_chaining_files
-    in_environment("PWD" => "test/data/chains") do
-      rake
-    end
-    assert File.exist?("test/data/chains/play.app"),
-      "'play.app' file should exist"
-    assert_status
-    remove_chaining_files
-  end
-
-  def test_file_creation_task
-    in_environment("PWD" => "test/data/file_creation_task") do
-      rake "prep"
-      rake "run"
-      rake "run"
-    end
-    assert(@err !~ /^cp src/, "Should not recopy data")
-  end
-
-  def test_dash_f_with_no_arg_foils_rakefile_lookup
-    rake "-I test/data/rakelib -rtest1 -f"
-    assert_match(/^TEST1$/, @out)
-  end
-
-  def test_dot_rake_files_can_be_loaded_with_dash_r
-    rake "-I test/data/rakelib -rtest2 -f"
-    assert_match(/^TEST2$/, @out)
-  end
-
-  def test_can_invoke_task_in_toplevel_namespace
-    in_environment("PWD" => "test/data/namespace") do
-      rake "copy"
-    end
-    assert_match(/^COPY$/, @out)
-  end
-
-  def test_can_invoke_task_in_nested_namespace
-    in_environment("PWD" => "test/data/namespace") do
-      rake "nest:copy"
-      assert_match(/^NEST COPY$/, @out)
-    end
-  end
-
-  def test_tasks_can_reference_task_in_same_namespace
-    in_environment("PWD" => "test/data/namespace") do
-      rake "nest:xx"
-      assert_match(/^NEST COPY$/m, @out)
-    end
-  end
-
-  def test_tasks_can_reference_task_in_other_namespaces
-    in_environment("PWD" => "test/data/namespace") do
-      rake "b:run"
-      assert_match(/^IN A\nIN B$/m, @out)
-    end
-  end
-
-  def test_anonymous_tasks_can_be_invoked_indirectly
-    in_environment("PWD" => "test/data/namespace") do
-      rake "anon"
-      assert_match(/^ANON COPY$/m, @out)
-    end
-  end
-
-  def test_rake_namespace_refers_to_toplevel
-    in_environment("PWD" => "test/data/namespace") do
-      rake "very:nested:run"
-      assert_match(/^COPY$/m, @out)
-    end
-  end
-
-  def test_file_task_are_not_scoped_by_namespaces
-    in_environment("PWD" => "test/data/namespace") do
-      rake "xyz.rb"
-      assert_match(/^XYZ1\nXYZ2$/m, @out)
-    end
-  end
-  
-  def test_rake_returns_status_error_values
-    in_environment("PWD" => "test/data/statusreturn") do
-      rake "exit5"
-      assert_status(5)
-    end
-  end
-
-  def test_rake_returns_no_status_error_on_normal_exit
-    in_environment("PWD" => "test/data/statusreturn") do
-      rake "normal"
-      assert_status(0)
-    end
-  end
-
-  private
-
-  def remove_chaining_files
-    %w(play.scpt play.app base).each do |fn|
-      FileUtils.rm_f File.join("test/data/chains", fn)
-    end
-  end
-
-  class << self
-    def format_command
-      @format_command ||= lambda { |ruby_options, rake_path, options|
-        "ruby #{ruby_options} #{rake_path} #{options}"
-      }
-    end
-    
-    def format_command=(fmt_command)
-      @format_command = fmt_command
-    end
-  end
-  
-  def rake(*option_list)
-    options = option_list.join(' ')
-    shell = Session::Shell.new
-    command = self.class.format_command[@ruby_options, @rake_path, options]
-    puts "COMMAND: [#{command}]" if @verbose
-    @out, @err = shell.execute command
-    @status = shell.exit_status
-    puts "STATUS:  [#{@status}]" if @verbose
-    puts "OUTPUT:  [#{@out}]" if @verbose
-    puts "ERROR:   [#{@err}]" if @verbose
-    puts "PWD:     [#{Dir.pwd}]" if @verbose
-    shell.close
-  end
-
-  def assert_status(expected_status=0)
-    assert_equal expected_status, @status
-  end
-end

data/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/rake-0.8.7/test/shellcommand.rb

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-
-exit((ARGV[0] || "0").to_i)

data/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/dirty_history-0.2.0/dirty_history/ruby/1.9.1/gems/rake-0.8.7/test/test_application.rb

@@ -1,675 +0,0 @@
-#!/usr/bin/env ruby
-
-begin
-  require 'rubygems'
-rescue LoadError
-  # got no gems
-end
-
-require 'test/unit'
-require 'rake'
-require 'test/rake_test_setup'
-require 'test/capture_stdout'
-require 'test/in_environment'
-
-TESTING_REQUIRE = [ ]
-
-######################################################################
-class TestApplication < Test::Unit::TestCase
-  include CaptureStdout
-  include InEnvironment
-  include TestMethods
-
-  def setup
-    @app = Rake::Application.new
-    @app.options.rakelib = []
-  end
-
-  def test_constant_warning
-    err = capture_stderr do @app.instance_eval { const_warning("Task") } end
-    assert_match(/warning/i, err)
-    assert_match(/deprecated/i, err)
-    assert_match(/Task/i, err)
-  end
-
-  def test_display_tasks
-    @app.options.show_task_pattern = //
-    @app.last_description = "COMMENT"
-    @app.define_task(Rake::Task, "t")
-    out = capture_stdout do @app.instance_eval { display_tasks_and_comments } end
-    assert_match(/^rake t/, out)
-    assert_match(/# COMMENT/, out)
-  end
-
-  def test_display_tasks_with_long_comments
-    in_environment('RAKE_COLUMNS' => '80') do
-      @app.options.show_task_pattern = //
-      @app.last_description = "1234567890" * 8
-      @app.define_task(Rake::Task, "t")
-      out = capture_stdout do @app.instance_eval { display_tasks_and_comments } end
-      assert_match(/^rake t/, out)
-      assert_match(/# 12345678901234567890123456789012345678901234567890123456789012345\.\.\./, out)
-    end
-  end
-
-  def test_display_tasks_with_task_name_wider_than_tty_display
-    in_environment('RAKE_COLUMNS' => '80') do
-      @app.options.show_task_pattern = //
-      description = "something short"
-      task_name = "task name" * 80
-      @app.last_description = "something short"
-      @app.define_task(Rake::Task, task_name )
-      out = capture_stdout do @app.instance_eval { display_tasks_and_comments } end
-      # Ensure the entire task name is output and we end up showing no description
-      assert_match(/rake #{task_name}  # .../, out)
-    end
-  end
-
-  def test_display_tasks_with_very_long_task_name_to_a_non_tty_shows_name_and_comment
-    @app.options.show_task_pattern = //
-    @app.tty_output = false
-    description = "something short"
-    task_name = "task name" * 80
-    @app.last_description = "something short"
-    @app.define_task(Rake::Task, task_name )
-    out = capture_stdout do @app.instance_eval { display_tasks_and_comments } end
-    # Ensure the entire task name is output and we end up showing no description
-    assert_match(/rake #{task_name}  # #{description}/, out)
-  end
-
-  def test_display_tasks_with_long_comments_to_a_non_tty_shows_entire_comment
-    @app.options.show_task_pattern = //
-    @app.tty_output = false
-    @app.last_description = "1234567890" * 8
-    @app.define_task(Rake::Task, "t")
-    out = capture_stdout do @app.instance_eval { display_tasks_and_comments } end
-    assert_match(/^rake t/, out)
-    assert_match(/# #{@app.last_description}/, out)
-  end
-
-  def test_display_tasks_with_long_comments_to_a_non_tty_with_columns_set_truncates_comments
-    in_environment("RAKE_COLUMNS" => '80') do
-      @app.options.show_task_pattern = //
-      @app.tty_output = false
-      @app.last_description = "1234567890" * 8
-      @app.define_task(Rake::Task, "t")
-      out = capture_stdout do @app.instance_eval { display_tasks_and_comments } end
-      assert_match(/^rake t/, out)
-      assert_match(/# 12345678901234567890123456789012345678901234567890123456789012345\.\.\./, out)
-    end
-  end
-
-  def test_display_tasks_with_full_descriptions
-    @app.options.show_task_pattern = //
-    @app.options.full_description = true
-    @app.last_description = "COMMENT"
-    @app.define_task(Rake::Task, "t")
-    out = capture_stdout do @app.instance_eval { display_tasks_and_comments } end
-    assert_match(/^rake t$/, out)
-    assert_match(/^ {4}COMMENT$/, out)
-  end
-
-  def test_finding_rakefile
-    assert_match(/Rakefile/i, @app.instance_eval { have_rakefile })
-  end
-
-  def test_not_finding_rakefile
-    @app.instance_eval { @rakefiles = ['NEVER_FOUND'] }
-    assert( ! @app.instance_eval do have_rakefile end )
-    assert_nil @app.rakefile
-  end
-
-  def test_load_rakefile
-    in_environment("PWD" => "test/data/unittest") do
-      @app.instance_eval do 
-        handle_options
-        options.silent = true
-        load_rakefile
-      end
-      assert_equal "rakefile", @app.rakefile.downcase
-      assert_match(%r(unittest$), Dir.pwd)
-    end
-  end
-
-  def test_load_rakefile_from_subdir
-    in_environment("PWD" => "test/data/unittest/subdir") do
-      @app.instance_eval do
-        handle_options
-        options.silent = true
-        load_rakefile
-      end
-      assert_equal "rakefile", @app.rakefile.downcase
-      assert_match(%r(unittest$), Dir.pwd)
-    end
-  end
-
-  def test_load_rakefile_not_found
-    in_environment("PWD" => "/", "RAKE_SYSTEM" => 'not_exist') do
-      @app.instance_eval do
-        handle_options
-        options.silent = true
-      end
-      ex = assert_exception(RuntimeError) do 
-        @app.instance_eval do raw_load_rakefile end 
-      end
-      assert_match(/no rakefile found/i, ex.message)
-    end
-  end
-
-  def test_load_from_system_rakefile
-    in_environment('RAKE_SYSTEM' => 'test/data/sys') do
-      @app.options.rakelib = []
-      @app.instance_eval do
-        handle_options
-        options.silent = true
-        options.load_system = true
-        options.rakelib = []
-        load_rakefile
-      end
-      assert_equal "test/data/sys", @app.system_dir
-      assert_nil @app.rakefile
-    end
-  end
-
-  def test_windows
-    assert ! (@app.windows? && @app.unix?)
-  end
-
-  def test_loading_imports
-    mock = flexmock("loader")
-    mock.should_receive(:load).with("x.dummy").once
-    @app.instance_eval do
-      add_loader("dummy", mock)
-      add_import("x.dummy")
-      load_imports
-    end
-  end
-
-  def test_building_imported_files_on_demand
-    mock = flexmock("loader")
-    mock.should_receive(:load).with("x.dummy").once
-    mock.should_receive(:make_dummy).with_no_args.once
-    @app.instance_eval do
-      intern(Rake::Task, "x.dummy").enhance do mock.make_dummy end
-        add_loader("dummy", mock)
-      add_import("x.dummy")
-      load_imports
-    end
-  end
-
-  def test_handle_options_should_strip_options_from_ARGV
-    assert !@app.options.trace
-
-    valid_option = '--trace'
-    ARGV.clear
-    ARGV << valid_option
-
-    @app.handle_options
-
-    assert !ARGV.include?(valid_option)
-    assert @app.options.trace
-  end
-
-  def test_good_run
-    ran = false
-    ARGV.clear
-    ARGV << '--rakelib=""'
-    @app.options.silent = true
-    @app.instance_eval do
-      intern(Rake::Task, "default").enhance { ran = true }
-    end
-    in_environment("PWD" => "test/data/default") do
-      @app.run
-    end
-    assert ran
-  end
-
-  def test_display_task_run
-    ran = false
-    ARGV.clear
-    ARGV << '-f' << '-s' << '--tasks' << '--rakelib=""'
-    @app.last_description = "COMMENT"
-    @app.define_task(Rake::Task, "default")
-    out = capture_stdout { @app.run }
-    assert @app.options.show_tasks
-    assert ! ran
-    assert_match(/rake default/, out)
-    assert_match(/# COMMENT/, out)
-  end
-
-  def test_display_prereqs
-    ran = false
-    ARGV.clear
-    ARGV << '-f' << '-s' << '--prereqs' << '--rakelib=""'
-    @app.last_description = "COMMENT"
-    t = @app.define_task(Rake::Task, "default")
-    t.enhance([:a, :b])
-    @app.define_task(Rake::Task, "a")
-    @app.define_task(Rake::Task, "b")
-    out = capture_stdout { @app.run }
-    assert @app.options.show_prereqs
-    assert ! ran
-    assert_match(/rake a$/, out)
-    assert_match(/rake b$/, out)
-    assert_match(/rake default\n( *(a|b)\n){2}/m, out)
-  end
-
-  def test_bad_run
-    @app.intern(Rake::Task, "default").enhance { fail }
-    ARGV.clear
-    ARGV << '-f' << '-s' <<  '--rakelib=""'
-    assert_exception(SystemExit) {
-      err = capture_stderr { @app.run }
-      assert_match(/see full trace/, err)
-    }
-  ensure
-    ARGV.clear
-  end
-
-  def test_bad_run_with_trace
-    @app.intern(Rake::Task, "default").enhance { fail }
-    ARGV.clear
-    ARGV << '-f' << '-s' << '-t'
-    assert_exception(SystemExit) {
-      err = capture_stderr { capture_stdout { @app.run } }
-      assert_no_match(/see full trace/, err)
-    }
-  ensure
-    ARGV.clear
-  end
-
-  def test_run_with_bad_options
-    @app.intern(Rake::Task, "default").enhance { fail }
-    ARGV.clear
-    ARGV << '-f' << '-s' << '--xyzzy'
-    assert_exception(SystemExit) {
-      err = capture_stderr { capture_stdout { @app.run } }
-    }
-  ensure
-    ARGV.clear
-  end
-end
-
-
-######################################################################
-class TestApplicationOptions < Test::Unit::TestCase
-  include CaptureStdout
-  include TestMethods
-
-  def setup
-    clear_argv
-    RakeFileUtils.verbose_flag = false
-    RakeFileUtils.nowrite_flag = false
-    TESTING_REQUIRE.clear
-  end
-
-  def teardown
-    clear_argv
-    RakeFileUtils.verbose_flag = false
-    RakeFileUtils.nowrite_flag = false
-  end
-  
-  def clear_argv
-    while ! ARGV.empty?
-      ARGV.pop
-    end
-  end
-
-  def test_default_options
-    opts = command_line
-    assert_nil opts.classic_namespace
-    assert_nil opts.dryrun
-    assert_nil opts.full_description
-    assert_nil opts.ignore_system
-    assert_nil opts.load_system
-    assert_nil opts.nosearch
-    assert_equal ['rakelib'], opts.rakelib
-    assert_nil opts.show_prereqs
-    assert_nil opts.show_task_pattern
-    assert_nil opts.show_tasks
-    assert_nil opts.silent
-    assert_nil opts.trace
-    assert_equal ['rakelib'], opts.rakelib
-    assert ! RakeFileUtils.verbose_flag
-    assert ! RakeFileUtils.nowrite_flag
-  end
-
-  def test_dry_run
-    flags('--dry-run', '-n') do |opts|
-      assert opts.dryrun
-      assert opts.trace
-      assert RakeFileUtils.verbose_flag
-      assert RakeFileUtils.nowrite_flag
-    end
-  end
-
-  def test_describe
-    flags('--describe') do |opts|
-      assert opts.full_description
-      assert opts.show_tasks
-      assert_equal(//.to_s, opts.show_task_pattern.to_s)
-    end
-  end
-
-  def test_describe_with_pattern
-    flags('--describe=X') do |opts|
-      assert opts.full_description
-      assert opts.show_tasks
-      assert_equal(/X/.to_s, opts.show_task_pattern.to_s)
-    end
-  end
-
-  def test_execute
-    $xyzzy = 0
-    flags('--execute=$xyzzy=1', '-e $xyzzy=1') do |opts|
-      assert_equal 1, $xyzzy
-      assert_equal :exit, @exit
-      $xyzzy = 0
-    end
-  end
-
-  def test_execute_and_continue
-    $xyzzy = 0
-    flags('--execute-continue=$xyzzy=1', '-E $xyzzy=1') do |opts|
-      assert_equal 1, $xyzzy
-      assert_not_equal :exit, @exit
-      $xyzzy = 0
-    end
-  end
-
-  def test_execute_and_print
-    $xyzzy = 0
-    flags('--execute-print=$xyzzy="pugh"', '-p $xyzzy="pugh"') do |opts|
-      assert_equal 'pugh', $xyzzy
-      assert_equal :exit, @exit
-      assert_match(/^pugh$/, @out)
-      $xyzzy = 0
-    end
-  end
-
-  def test_help
-    flags('--help', '-H', '-h') do |opts|
-      assert_match(/\Arake/, @out)
-      assert_match(/\boptions\b/, @out)
-      assert_match(/\btargets\b/, @out)
-      assert_equal :exit, @exit
-      assert_equal :exit, @exit
-    end
-  end
-
-  def test_libdir
-    flags(['--libdir', 'xx'], ['-I', 'xx'], ['-Ixx']) do |opts|
-      $:.include?('xx')
-    end
-  ensure
-    $:.delete('xx')
-  end
-
-  def test_rakefile
-    flags(['--rakefile', 'RF'], ['--rakefile=RF'], ['-f', 'RF'], ['-fRF']) do |opts|
-      assert_equal ['RF'], @app.instance_eval { @rakefiles }
-    end
-  end
-
-  def test_rakelib
-    flags(['--rakelibdir', 'A:B:C'], ['--rakelibdir=A:B:C'], ['-R', 'A:B:C'], ['-RA:B:C']) do |opts|
-      assert_equal ['A', 'B', 'C'], opts.rakelib
-    end
-  end
-
-  def test_require
-    flags(['--require', 'test/reqfile'], '-rtest/reqfile2', '-rtest/reqfile3') do |opts|
-    end
-    assert TESTING_REQUIRE.include?(1)
-    assert TESTING_REQUIRE.include?(2)
-    assert TESTING_REQUIRE.include?(3)
-    assert_equal 3, TESTING_REQUIRE.size
-  end
-
-  def test_missing_require
-    ex = assert_exception(LoadError) do
-      flags(['--require', 'test/missing']) do |opts|
-      end
-    end
-    assert_match(/no such file/, ex.message)
-    assert_match(/test\/missing/, ex.message)
-  end
-
-  def test_prereqs
-    flags('--prereqs', '-P') do |opts|
-      assert opts.show_prereqs
-    end
-  end
-
-  def test_quiet
-    flags('--quiet', '-q') do |opts|
-      assert ! RakeFileUtils.verbose_flag
-      assert ! opts.silent
-    end
-  end
-
-  def test_no_search
-    flags('--nosearch', '--no-search', '-N') do |opts|
-      assert opts.nosearch
-    end
-  end
-
-  def test_silent
-    flags('--silent', '-s') do |opts|
-      assert ! RakeFileUtils.verbose_flag
-      assert opts.silent
-    end
-  end
-
-  def test_system
-    flags('--system', '-g') do |opts|
-      assert opts.load_system
-    end
-  end
-
-  def test_no_system
-    flags('--no-system', '-G') do |opts|
-      assert opts.ignore_system
-    end
-  end
-
-  def test_trace
-    flags('--trace', '-t') do |opts|
-      assert opts.trace
-      assert RakeFileUtils.verbose_flag
-      assert ! RakeFileUtils.nowrite_flag
-    end
-  end
-
-  def test_trace_rules
-    flags('--rules') do |opts|
-      assert opts.trace_rules
-    end
-  end
-
-  def test_tasks
-    flags('--tasks', '-T') do |opts|
-      assert opts.show_tasks
-      assert_equal(//.to_s, opts.show_task_pattern.to_s)
-    end
-    flags(['--tasks', 'xyz'], ['-Txyz']) do |opts|
-      assert opts.show_tasks
-      assert_equal(/xyz/, opts.show_task_pattern)
-    end
-  end
-
-  def test_verbose
-    flags('--verbose', '-V') do |opts|
-      assert RakeFileUtils.verbose_flag
-      assert ! opts.silent
-    end
-  end
-
-  def test_version
-    flags('--version', '-V') do |opts|
-      assert_match(/\bversion\b/, @out)
-      assert_match(/\b#{RAKEVERSION}\b/, @out)
-      assert_equal :exit, @exit
-    end
-  end
-  
-  def test_classic_namespace
-    flags(['--classic-namespace'], ['-C', '-T', '-P', '-n', '-s', '-t']) do |opts|
-      assert opts.classic_namespace
-      assert_equal opts.show_tasks, $show_tasks
-      assert_equal opts.show_prereqs, $show_prereqs
-      assert_equal opts.trace, $trace
-      assert_equal opts.dryrun, $dryrun
-      assert_equal opts.silent, $silent
-    end
-  end
-
-  def test_bad_option
-    capture_stderr do
-      ex = assert_exception(OptionParser::InvalidOption) do
-        flags('--bad-option') 
-      end
-      if ex.message =~ /^While/ # Ruby 1.9 error message
-        assert_match(/while parsing/i, ex.message)
-      else                      # Ruby 1.8 error message
-        assert_match(/(invalid|unrecognized) option/i, ex.message)
-        assert_match(/--bad-option/, ex.message)
-      end
-    end
-  end
-
-  def test_task_collection
-    command_line("a", "b")
-    assert_equal ["a", "b"], @tasks.sort
-  end
-  
-  def test_default_task_collection
-    command_line()
-    assert_equal ["default"], @tasks
-  end
-  
-  def test_environment_definition
-    ENV.delete('TESTKEY')
-    command_line("a", "TESTKEY=12")
-    assert_equal ["a"], @tasks.sort
-    assert '12', ENV['TESTKEY']
-  end
-
-  private 
-
-  def flags(*sets)
-    sets.each do |set|
-      ARGV.clear
-      @out = capture_stdout { 
-        @exit = catch(:system_exit) { opts = command_line(*set) }
-      }
-      yield(@app.options) if block_given?
-    end
-  end
-
-  def command_line(*options)
-    options.each do |opt| ARGV << opt end
-    @app = Rake::Application.new
-    def @app.exit(*args)
-      throw :system_exit, :exit
-    end
-    @app.instance_eval do
-      handle_options
-      collect_tasks
-    end
-    @tasks = @app.top_level_tasks
-    @app.options
-  end
-end
-
-class TestTaskArgumentParsing < Test::Unit::TestCase
-  def setup
-    @app = Rake::Application.new
-  end
-  
-  def test_name_only
-    name, args = @app.parse_task_string("name")
-    assert_equal "name", name
-    assert_equal [], args
-  end
-  
-  def test_empty_args
-    name, args = @app.parse_task_string("name[]")
-    assert_equal "name", name
-    assert_equal [], args
-  end
-  
-  def test_one_argument
-    name, args = @app.parse_task_string("name[one]")
-    assert_equal "name", name
-    assert_equal ["one"], args
-  end
-  
-  def test_two_arguments
-    name, args = @app.parse_task_string("name[one,two]")
-    assert_equal "name", name
-    assert_equal ["one", "two"], args
-  end
-  
-  def test_can_handle_spaces_between_args
-    name, args = @app.parse_task_string("name[one, two,\tthree , \tfour]")
-    assert_equal "name", name
-    assert_equal ["one", "two", "three", "four"], args
-  end
-
-  def test_keeps_embedded_spaces
-    name, args = @app.parse_task_string("name[a one ana, two]")
-    assert_equal "name", name
-    assert_equal ["a one ana", "two"], args
-  end
-
-end
-
-class TestTaskArgumentParsing < Test::Unit::TestCase
-  include InEnvironment
-
-  def test_terminal_width_using_env
-    app = Rake::Application.new
-    in_environment('RAKE_COLUMNS' => '1234') do
-      assert_equal 1234, app.terminal_width
-    end
-  end
-
-  def test_terminal_width_using_stty
-    app = Rake::Application.new
-    flexmock(app,
-      :unix? => true,
-      :dynamic_width_stty => 1235,
-      :dynamic_width_tput => 0)
-    in_environment('RAKE_COLUMNS' => nil) do
-      assert_equal 1235, app.terminal_width
-    end
-  end
-
-  def test_terminal_width_using_tput
-    app = Rake::Application.new
-    flexmock(app,
-      :unix? => true,
-      :dynamic_width_stty => 0,
-      :dynamic_width_tput => 1236)
-    in_environment('RAKE_COLUMNS' => nil) do
-      assert_equal 1236, app.terminal_width
-    end
-  end
-
-  def test_terminal_width_using_hardcoded_80
-    app = Rake::Application.new
-    flexmock(app, :unix? => false)
-    in_environment('RAKE_COLUMNS' => nil) do
-      assert_equal 80, app.terminal_width
-    end
-  end
-
-  def test_terminal_width_with_failure
-    app = Rake::Application.new
-    flexmock(app).should_receive(:unix?).and_throw(RuntimeError)
-    in_environment('RAKE_COLUMNS' => nil) do
-      assert_equal 80, app.terminal_width
-    end
-  end
-end