gemrage 0.3.2 → 0.4.0

data/vendor/ruby/1.8/gems/rake-0.8.7/test/test_tasks.rb

@@ -0,0 +1,374 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'fileutils'
+require 'rake'
+require 'test/filecreation'
+require 'test/capture_stdout'
+require 'test/rake_test_setup'
+
+######################################################################
+class TestTask < Test::Unit::TestCase
+  include CaptureStdout
+  include Rake
+  include TestMethods
+
+  def setup
+    Task.clear
+  end
+
+  def test_create
+    arg = nil
+    t = task(:name) { |task| arg = task; 1234 }
+    assert_equal "name", t.name
+    assert_equal [], t.prerequisites
+    assert t.needed?
+    t.execute(0)
+    assert_equal t, arg
+    assert_nil t.source
+    assert_equal [], t.sources
+  end
+
+  def test_inspect
+    t = task(:foo, :needs => [:bar, :baz])
+    assert_equal "<Rake::Task foo => [bar, baz]>", t.inspect
+  end
+
+  def test_invoke
+    runlist = []
+    t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
+    t2 = task(:t2) { |t| runlist << t.name }
+    t3 = task(:t3) { |t| runlist << t.name }
+    assert_equal ["t2", "t3"], t1.prerequisites
+    t1.invoke
+    assert_equal ["t2", "t3", "t1"], runlist
+  end
+
+  def test_invoke_with_circular_dependencies
+    runlist = []
+    t1 = task(:t1 => [:t2]) { |t| runlist << t.name; 3321 }
+    t2 = task(:t2 => [:t1]) { |t| runlist << t.name }
+    assert_equal ["t2"], t1.prerequisites
+    assert_equal ["t1"], t2.prerequisites
+    ex = assert_exception RuntimeError do
+      t1.invoke
+    end
+    assert_match(/circular dependency/i, ex.message)
+    assert_match(/t1 => t2 => t1/, ex.message)
+  end
+
+  def test_dry_run_prevents_actions
+    Rake.application.options.dryrun = true
+    runlist = []
+    t1 = task(:t1) { |t| runlist << t.name; 3321 }
+    out = capture_stdout { t1.invoke }
+    assert_match(/execute .*t1/i, out)
+    assert_match(/dry run/i, out)
+    assert_no_match(/invoke/i, out)
+    assert_equal [], runlist
+  ensure
+    Rake.application.options.dryrun = false
+  end
+
+  def test_tasks_can_be_traced
+    Rake.application.options.trace = true
+    t1 = task(:t1)
+    out = capture_stdout {
+      t1.invoke
+    }
+    assert_match(/invoke t1/i, out)
+    assert_match(/execute t1/i, out)
+  ensure
+    Rake.application.options.trace = false
+  end
+
+  def test_no_double_invoke
+    runlist = []
+    t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
+    t2 = task(:t2 => [:t3]) { |t| runlist << t.name }
+    t3 = task(:t3) { |t| runlist << t.name }
+    t1.invoke
+    assert_equal ["t3", "t2", "t1"], runlist
+  end
+
+  def test_can_double_invoke_with_reenable
+    runlist = []
+    t1 = task(:t1) { |t| runlist << t.name }
+    t1.invoke
+    t1.reenable
+    t1.invoke
+    assert_equal ["t1", "t1"], runlist
+  end
+
+  def test_clear
+    t = task("t" => "a") { }
+    t.clear
+    assert t.prerequisites.empty?, "prerequisites should be empty"
+    assert t.actions.empty?, "actions should be empty"
+  end
+
+  def test_clear_prerequisites
+    t = task("t" => ["a", "b"])
+    assert_equal ['a', 'b'], t.prerequisites
+    t.clear_prerequisites
+    assert_equal [], t.prerequisites
+  end
+
+  def test_clear_actions
+    t = task("t") { }
+    t.clear_actions
+    assert t.actions.empty?, "actions should be empty"
+  end
+
+  def test_find
+    task :tfind
+    assert_equal "tfind", Task[:tfind].name
+    ex = assert_exception(RuntimeError) { Task[:leaves] }
+    assert_equal "Don't know how to build task 'leaves'", ex.message
+  end
+
+  def test_defined
+    assert ! Task.task_defined?(:a)
+    task :a
+    assert Task.task_defined?(:a)
+  end
+
+  def test_multi_invocations
+    runs = []
+    p = proc do |t| runs << t.name end
+    task({:t1=>[:t2,:t3]}, &p)
+    task({:t2=>[:t3]}, &p)
+    task(:t3, &p)
+    Task[:t1].invoke
+    assert_equal ["t1", "t2", "t3"], runs.sort
+  end
+
+  def test_task_list
+    task :t2
+    task :t1 => [:t2]
+    assert_equal ["t1", "t2"], Task.tasks.collect {|t| t.name}
+  end
+
+  def test_task_gives_name_on_to_s
+    task :abc
+    assert_equal "abc", Task[:abc].to_s
+  end
+
+  def test_symbols_can_be_prerequisites
+    task :a => :b
+    assert_equal ["b"], Task[:a].prerequisites
+  end
+
+  def test_strings_can_be_prerequisites
+    task :a => "b"
+    assert_equal ["b"], Task[:a].prerequisites
+  end
+
+  def test_arrays_can_be_prerequisites
+    task :a => ["b", "c"]
+    assert_equal ["b", "c"], Task[:a].prerequisites
+  end
+
+  def test_filelists_can_be_prerequisites
+    task :a => FileList.new.include("b", "c")
+    assert_equal ["b", "c"], Task[:a].prerequisites
+  end
+
+  def test_investigation_output
+    t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 }
+    task(:t2)
+    task(:t3)
+    out = t1.investigation
+    assert_match(/class:\s*Rake::Task/, out)
+    assert_match(/needed:\s*true/, out)
+    assert_match(/pre-requisites:\s*--t[23]/, out)
+  end
+
+
+  def test_extended_comments
+    desc %{
+      This is a comment.
+
+      And this is the extended comment.
+      name -- Name of task to execute.
+      rev  -- Software revision to use.
+    }
+    t = task(:t, :name, :rev)
+    assert_equal "[name,rev]", t.arg_description
+    assert_equal "This is a comment.", t.comment
+    assert_match(/^\s*name -- Name/, t.full_comment)
+    assert_match(/^\s*rev  -- Software/, t.full_comment)
+    assert_match(/\A\s*This is a comment\.$/, t.full_comment)
+  end
+
+  def test_multiple_comments
+    desc "line one"
+    t = task(:t)
+    desc "line two"
+    task(:t)
+    assert_equal "line one / line two", t.comment
+  end
+
+  def test_settable_comments
+    t = task(:t)
+    t.comment = "HI"
+    assert_equal "HI", t.comment
+  end
+end
+
+######################################################################
+class TestTaskWithArguments < Test::Unit::TestCase
+  include CaptureStdout
+  include Rake
+  include TestMethods
+
+  def setup
+    Task.clear
+  end
+
+  def test_no_args_given
+    t = task :t
+    assert_equal [], t.arg_names
+  end
+
+  def test_args_given
+    t = task :t, :a, :b
+    assert_equal [:a, :b], t.arg_names
+  end
+
+  def test_name_and_needs
+    t = task(:t => [:pre])
+    assert_equal "t", t.name
+    assert_equal [], t.arg_names
+    assert_equal ["pre"], t.prerequisites
+  end
+
+  def test_name_and_explicit_needs
+    t = task(:t, :needs => [:pre])
+    assert_equal "t", t.name
+    assert_equal [], t.arg_names
+    assert_equal ["pre"], t.prerequisites
+  end
+
+  def test_name_args_and_explicit_needs
+    t = task(:t, :x, :y, :needs => [:pre])
+    assert_equal "t", t.name
+    assert_equal [:x, :y], t.arg_names
+    assert_equal ["pre"], t.prerequisites
+  end
+
+  def test_illegal_keys_in_task_name_hash
+    assert_exception RuntimeError do
+      t = task(:t, :x, :y => 1, :needs => [:pre])
+    end
+  end
+
+  def test_arg_list_is_empty_if_no_args_given
+    t = task(:t) { |tt, args| assert_equal({}, args.to_hash) }
+    t.invoke(1, 2, 3)
+  end
+
+  def test_tasks_can_access_arguments_as_hash
+    t = task :t, :a, :b, :c do |tt, args|
+      assert_equal({:a => 1, :b => 2, :c => 3}, args.to_hash)
+      assert_equal 1, args[:a]
+      assert_equal 2, args[:b]
+      assert_equal 3, args[:c]
+      assert_equal 1, args.a
+      assert_equal 2, args.b
+      assert_equal 3, args.c
+    end
+    t.invoke(1, 2, 3)
+  end
+
+  def test_actions_of_various_arity_are_ok_with_args
+    notes = []
+    t = task(:t, :x) do
+      notes << :a
+    end
+    t.enhance do | |
+      notes << :b
+    end
+    t.enhance do |task|
+      notes << :c
+      assert_kind_of Task, task
+    end
+    t.enhance do |t2, args|
+      notes << :d
+      assert_equal t, t2
+      assert_equal({:x => 1}, args.to_hash)
+    end
+    assert_nothing_raised do t.invoke(1) end
+    assert_equal [:a, :b, :c, :d], notes
+  end
+
+  def test_arguments_are_passed_to_block
+    t = task(:t, :a, :b) { |tt, args|
+      assert_equal( { :a => 1, :b => 2 }, args.to_hash )
+    }
+    t.invoke(1, 2)
+  end
+
+  def test_extra_parameters_are_ignored
+    t = task(:t, :a) { |tt, args|
+      assert_equal 1, args.a
+      assert_nil args.b
+    }
+    t.invoke(1, 2)
+  end
+
+  def test_arguments_are_passed_to_all_blocks
+    counter = 0
+    t = task :t, :a
+    task :t do |tt, args|
+      assert_equal 1, args.a
+      counter += 1
+    end
+    task :t do |tt, args|
+      assert_equal 1, args.a
+      counter += 1
+    end
+    t.invoke(1)
+    assert_equal 2, counter
+  end
+
+  def test_block_with_no_parameters_is_ok
+    t = task(:t) { }
+    t.invoke(1, 2)
+  end
+
+  def test_name_with_args
+    desc "T"
+    t = task(:tt, :a, :b)
+    assert_equal "tt", t.name
+    assert_equal "T", t.comment
+    assert_equal "[a,b]", t.arg_description
+    assert_equal "tt[a,b]", t.name_with_args
+    assert_equal [:a, :b],t.arg_names
+  end
+
+  def test_named_args_are_passed_to_prereqs
+    value = nil
+    pre = task(:pre, :rev) { |t, args| value = args.rev }
+    t = task(:t, :name, :rev, :needs => [:pre])
+    t.invoke("bill", "1.2")
+    assert_equal "1.2", value
+  end
+
+  def test_args_not_passed_if_no_prereq_names
+    pre = task(:pre) { |t, args|
+      assert_equal({}, args.to_hash)
+      assert_equal "bill", args.name
+    }
+    t = task(:t, :name, :rev, :needs => [:pre])
+    t.invoke("bill", "1.2")
+  end
+
+  def test_args_not_passed_if_no_arg_names
+    pre = task(:pre, :rev) { |t, args|
+      assert_equal({}, args.to_hash)
+    }
+    t = task(:t, :needs => [:pre])
+    t.invoke("bill", "1.2")
+  end
+end

data/vendor/ruby/1.8/gems/rake-0.8.7/test/test_test_task.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'rake/testtask'
+
+class TestTestTask < Test::Unit::TestCase
+  include Rake
+  include TestMethods
+  
+  def setup
+    Task.clear
+    ENV.delete('TEST')
+  end
+
+  def teardown
+    FileUtils.rm_rf("testdata")
+  end
+
+  def test_no_task
+    assert ! Task.task_defined?(:test)
+  end
+
+  def test_defaults
+    tt = Rake::TestTask.new do |t| end
+    assert_not_nil tt
+    assert_equal :test, tt.name
+    assert_equal ['lib'], tt.libs
+    assert_equal 'test/test*.rb', tt.pattern
+    assert_equal false, tt.verbose
+    assert Task.task_defined?(:test)
+  end
+
+  def test_non_defaults
+    tt = Rake::TestTask.new(:example) do |t|
+      t.libs = ['src', 'ext']
+      t.pattern = 'test/tc_*.rb'
+      t.verbose = true
+    end
+    assert_not_nil tt
+    assert_equal :example, tt.name
+    assert_equal ['src', 'ext'], tt.libs
+    assert_equal 'test/tc_*.rb', tt.pattern
+    assert_equal true, tt.verbose
+    assert Task.task_defined?(:example)
+  end
+
+  def test_pattern
+    tt = Rake::TestTask.new do |t|
+      t.pattern = '*.rb'
+    end
+    assert_equal ['install.rb'], tt.file_list.to_a
+  end
+
+  def test_env_test
+    ENV['TEST'] = 'testfile.rb'
+    tt = Rake::TestTask.new do |t|
+      t.pattern = '*'
+    end
+    assert_equal ["testfile.rb"], tt.file_list.to_a
+  end
+
+  def test_test_files
+    tt = Rake::TestTask.new do |t|
+      t.test_files = FileList['a.rb', 'b.rb']
+    end
+    assert_equal ["a.rb", 'b.rb'], tt.file_list.to_a
+  end
+
+  def test_both_pattern_and_test_files
+    tt = Rake::TestTask.new do |t|
+      t.test_files = FileList['a.rb', 'b.rb']
+      t.pattern = '*.rb'
+    end
+    assert_equal ['a.rb', 'b.rb', 'install.rb'], tt.file_list.to_a
+  end
+
+end

data/vendor/ruby/1.8/gems/rake-0.8.7/test/test_top_level_functions.rb

@@ -0,0 +1,86 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'rubygems'
+rescue LoadError
+  # got no gems
+end
+
+require 'test/unit'
+require 'flexmock/test_unit'
+require 'test/capture_stdout'
+require 'test/rake_test_setup'
+require 'rake'
+
+class TestTopLevelFunctions < Test::Unit::TestCase
+  include CaptureStdout
+  include TestMethods
+
+  def setup
+    super
+    @app = Rake.application
+    Rake.application = flexmock("app")
+  end
+
+  def teardown
+    Rake.application = @app
+    super
+  end
+
+  def test_namespace
+    Rake.application.should_receive(:in_namespace).with("xyz", any).once
+    namespace "xyz" do end
+  end
+
+  def test_import
+    Rake.application.should_receive(:add_import).with("x").once.ordered
+    Rake.application.should_receive(:add_import).with("y").once.ordered
+    Rake.application.should_receive(:add_import).with("z").once.ordered
+    import('x', 'y', 'z')
+  end
+
+  def test_when_writing
+    out = capture_stdout do
+      when_writing("NOTWRITING") do
+        puts "WRITING"
+      end
+    end
+    assert_equal "WRITING\n", out
+  end
+
+  def test_when_not_writing
+    RakeFileUtils.nowrite_flag = true
+    out = capture_stdout do
+      when_writing("NOTWRITING") do
+        puts "WRITING"
+      end
+    end
+    assert_equal "DRYRUN: NOTWRITING\n", out
+  ensure
+    RakeFileUtils.nowrite_flag = false
+  end
+
+  def test_missing_constants_task
+    Rake.application.should_receive(:const_warning).with(:Task).once
+    Object.const_missing(:Task)
+  end
+
+  def test_missing_constants_file_task
+    Rake.application.should_receive(:const_warning).with(:FileTask).once
+    Object.const_missing(:FileTask)
+  end
+
+  def test_missing_constants_file_creation_task
+    Rake.application.should_receive(:const_warning).with(:FileCreationTask).once
+    Object.const_missing(:FileCreationTask)
+  end
+
+  def test_missing_constants_rake_app
+    Rake.application.should_receive(:const_warning).with(:RakeApp).once
+    Object.const_missing(:RakeApp)
+  end
+
+  def test_missing_other_constant
+    assert_exception(NameError) do Object.const_missing(:Xyz) end
+  end
+end

data/vendor/ruby/1.8/gems/rake-0.8.7/test/test_win32.rb

@@ -0,0 +1,72 @@
+#!/usr/bin/env ruby
+
+require 'test/unit'
+require 'test/rake_test_setup'
+require 'test/in_environment'
+
+require 'rake'
+
+class TestWin32 < Test::Unit::TestCase
+  include InEnvironment
+  include TestMethods
+
+  Win32 = Rake::Win32
+
+  def test_win32_system_dir_uses_home_if_defined
+    in_environment('RAKE_SYSTEM' => nil, 'HOME' => 'C:\\HP') do
+      assert_equal "C:/HP/Rake", Win32.win32_system_dir
+    end
+  end
+
+  def test_win32_system_dir_uses_homedrive_homepath_when_no_home_defined
+    in_environment(
+      'RAKE_SYSTEM' => nil,
+      'HOME' => nil,
+      'HOMEDRIVE' => "C:",
+      'HOMEPATH' => "\\HP"
+      ) do
+      assert_equal "C:/HP/Rake", Win32.win32_system_dir
+    end
+  end
+
+  def test_win32_system_dir_uses_appdata_when_no_home_or_home_combo
+    in_environment(
+      'RAKE_SYSTEM' => nil,
+      'HOME' => nil,
+      'HOMEDRIVE' => nil,
+      'HOMEPATH' => nil,
+      'APPDATA' => "C:\\Documents and Settings\\HP\\Application Data"
+      ) do
+      assert_equal "C:/Documents and Settings/HP/Application Data/Rake", Win32.win32_system_dir
+    end
+  end
+
+  def test_win32_system_dir_fallback_to_userprofile_otherwise
+    in_environment(
+      'RAKE_SYSTEM' => nil,
+      'HOME' => nil,
+      'HOMEDRIVE' => nil,
+      'HOMEPATH' => nil,
+      'APPDATA' => nil,
+      'USERPROFILE' => "C:\\Documents and Settings\\HP"
+      ) do
+      assert_equal "C:/Documents and Settings/HP/Rake", Win32.win32_system_dir
+    end
+  end
+
+  def test_win32_system_dir_nil_of_no_env_vars
+    in_environment(
+      'RAKE_SYSTEM' => nil,
+      'HOME' => nil,
+      'HOMEDRIVE' => nil,
+      "HOMEPATH" => nil,
+      'APPDATA' => nil,
+      "USERPROFILE" => nil
+      ) do
+      assert_exception(Rake::Win32::Win32HomeError) do
+        Win32.win32_system_dir
+      end
+    end
+  end
+
+end

data/vendor/ruby/1.8/specifications/configuration-1.1.0.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{configuration}
+  s.version = "1.1.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Ara T. Howard"]
+  s.date = %q{2009-09-23}
+  s.email = %q{ara.t.howard@gmail.com}
+  s.files = ["config", "config/a.rb", "config/b.rb", "config/c.rb", "config/d.rb", "config/e.rb", "configuration.gemspec", "lib", "lib/configuration.rb", "Rakefile", "README", "README.erb", "samples", "samples/a.rb", "samples/b.rb", "samples/c.rb", "samples/d.rb", "samples/e.rb"]
+  s.homepage = %q{http://github.com/ahoward/configuration/tree/master}
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{codeforpeople}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{configuration}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/vendor/ruby/1.8/specifications/launchy-0.3.7.gemspec

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{launchy}
+  s.version = "0.3.7"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Jeremy Hinegardner"]
+  s.date = %q{2010-07-19}
+  s.default_executable = %q{launchy}
+  s.description = %q{Launchy is helper class for launching cross-platform applications in a
+fire and forget manner.
+
+There are application concepts (browser, email client, etc) that are
+common across all platforms, and they may be launched differently on
+each platform.  Launchy is here to make a common approach to launching
+external application from within ruby programs.}
+  s.email = %q{jeremy@copiousfreetime.org}
+  s.executables = ["launchy"]
+  s.extra_rdoc_files = ["README", "HISTORY", "LICENSE", "lib/launchy/application.rb", "lib/launchy/browser.rb", "lib/launchy/command_line.rb", "lib/launchy/paths.rb", "lib/launchy/version.rb", "lib/launchy.rb"]
+  s.files = ["bin/launchy", "lib/launchy/application.rb", "lib/launchy/browser.rb", "lib/launchy/command_line.rb", "lib/launchy/paths.rb", "lib/launchy/version.rb", "lib/launchy.rb", "spec/application_spec.rb", "spec/browser_spec.rb", "spec/launchy_spec.rb", "spec/paths_spec.rb", "spec/spec_helper.rb", "spec/version_spec.rb", "spec/tattle-host-os.yml", "README", "HISTORY", "LICENSE", "tasks/announce.rake", "tasks/distribution.rake", "tasks/documentation.rake", "tasks/rspec.rake", "tasks/rubyforge.rake", "tasks/config.rb", "tasks/utils.rb", "Rakefile", "gemspec.rb"]
+  s.homepage = %q{http://copiousfreetime.rubyforge.org/launchy/}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--main", "README"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{copiousfreetime}
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Launchy is helper class for launching cross-platform applications in a fire and forget manner}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<rake>, [">= 0.8.1"])
+      s.add_runtime_dependency(%q<configuration>, [">= 0.0.5"])
+    else
+      s.add_dependency(%q<rake>, [">= 0.8.1"])
+      s.add_dependency(%q<configuration>, [">= 0.0.5"])
+    end
+  else
+    s.add_dependency(%q<rake>, [">= 0.8.1"])
+    s.add_dependency(%q<configuration>, [">= 0.0.5"])
+  end
+end