rake-10.0.4/0000755000004100000410000000000012124115317012543 5ustar www-datawww-datarake-10.0.4/MIT-LICENSE0000644000004100000410000000204612124115317014201 0ustar www-datawww-dataCopyright (c) 2003, 2004 Jim Weirich 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. rake-10.0.4/test/0000755000004100000410000000000012124115317013522 5ustar www-datawww-datarake-10.0.4/test/test_rake_name_space.rb0000644000004100000410000000166212124115317020210 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakeNameSpace < Rake::TestCase class TM include Rake::TaskManager end def test_namespace_creation mgr = TM.new ns = Rake::NameSpace.new(mgr, []) refute_nil ns end def test_namespace_lookup mgr = TM.new ns = mgr.in_namespace("n") do mgr.define_task(Rake::Task, "t") end refute_nil ns["t"] assert_equal mgr["n:t"], ns["t"] end def test_namespace_reports_tasks_it_owns mgr = TM.new nns = nil ns = mgr.in_namespace("n") do mgr.define_task(Rake::Task, :x) mgr.define_task(Rake::Task, :y) nns = mgr.in_namespace("nn") do mgr.define_task(Rake::Task, :z) end end mgr.in_namespace("m") do mgr.define_task(Rake::Task, :x) end assert_equal ["n:nn:z", "n:x", "n:y"], ns.tasks.map { |tsk| tsk.name } assert_equal ["n:nn:z"], nns.tasks.map {|t| t.name} end end rake-10.0.4/test/test_private_reader.rb0000644000004100000410000000127412124115317020106 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'rake/private_reader' class TestPrivateAttrs < Rake::TestCase class Sample include Rake::PrivateReader private_reader :reader, :a def initialize @reader = :RVALUE end def get_reader reader end end def setup super @sample = Sample.new end def test_private_reader_is_private assert_private do @sample.reader end assert_private do @sample.a end end def test_private_reader_returns_data assert_equal :RVALUE, @sample.get_reader end private def assert_private ex = assert_raises(NoMethodError) do yield end assert_match(/private/, ex.message) end end rake-10.0.4/test/test_rake_path_map.rb0000644000004100000410000001303712124115317017705 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakePathMap < Rake::TestCase def test_returns_self_with_no_args assert_equal "abc.rb", "abc.rb".pathmap end def test_s_returns_file_separator sep = File::ALT_SEPARATOR || File::SEPARATOR assert_equal sep, "abc.rb".pathmap("%s") assert_equal sep, "".pathmap("%s") assert_equal "a#{sep}b", "a/b".pathmap("%d%s%f") end def test_f_returns_basename assert_equal "abc.rb", "abc.rb".pathmap("%f") assert_equal "abc.rb", "this/is/a/dir/abc.rb".pathmap("%f") assert_equal "abc.rb", "/this/is/a/dir/abc.rb".pathmap("%f") end def test_n_returns_basename_without_extension assert_equal "abc", "abc.rb".pathmap("%n") assert_equal "abc", "abc".pathmap("%n") assert_equal "abc", "this/is/a/dir/abc.rb".pathmap("%n") assert_equal "abc", "/this/is/a/dir/abc.rb".pathmap("%n") assert_equal "abc", "/this/is/a/dir/abc".pathmap("%n") end def test_d_returns_dirname assert_equal ".", "abc.rb".pathmap("%d") assert_equal "/", "/abc".pathmap("%d") assert_equal "this/is/a/dir", "this/is/a/dir/abc.rb".pathmap("%d") assert_equal "/this/is/a/dir", "/this/is/a/dir/abc.rb".pathmap("%d") end def test_9d_returns_partial_dirname assert_equal "this/is", "this/is/a/dir/abc.rb".pathmap("%2d") assert_equal "this", "this/is/a/dir/abc.rb".pathmap("%1d") assert_equal ".", "this/is/a/dir/abc.rb".pathmap("%0d") assert_equal "dir", "this/is/a/dir/abc.rb".pathmap("%-1d") assert_equal "a/dir", "this/is/a/dir/abc.rb".pathmap("%-2d") assert_equal "this/is/a/dir", "this/is/a/dir/abc.rb".pathmap("%100d") assert_equal "this/is/a/dir", "this/is/a/dir/abc.rb".pathmap("%-100d") end def test_x_returns_extension assert_equal "", "abc".pathmap("%x") assert_equal ".rb", "abc.rb".pathmap("%x") assert_equal ".rb", "abc.xyz.rb".pathmap("%x") assert_equal "", ".depends".pathmap("%x") assert_equal "", "dir/.depends".pathmap("%x") end def test_X_returns_everything_but_extension assert_equal "abc", "abc".pathmap("%X") assert_equal "abc", "abc.rb".pathmap("%X") assert_equal "abc.xyz", "abc.xyz.rb".pathmap("%X") assert_equal "ab.xyz", "ab.xyz.rb".pathmap("%X") assert_equal "a.xyz", "a.xyz.rb".pathmap("%X") assert_equal "abc", "abc.rb".pathmap("%X") assert_equal "ab", "ab.rb".pathmap("%X") assert_equal "a", "a.rb".pathmap("%X") assert_equal ".depends", ".depends".pathmap("%X") assert_equal "a/dir/.depends", "a/dir/.depends".pathmap("%X") assert_equal "/.depends", "/.depends".pathmap("%X") end def test_p_returns_entire_pathname assert_equal "abc.rb", "abc.rb".pathmap("%p") assert_equal "this/is/a/dir/abc.rb", "this/is/a/dir/abc.rb".pathmap("%p") assert_equal "/this/is/a/dir/abc.rb", "/this/is/a/dir/abc.rb".pathmap("%p") end def test_dash_returns_empty_string assert_equal "", "abc.rb".pathmap("%-") assert_equal "abc.rb", "abc.rb".pathmap("%X%-%x") end def test_percent_percent_returns_percent assert_equal "a%b", "".pathmap("a%%b") end def test_undefined_percent_causes_error assert_raises(ArgumentError) { "dir/abc.rb".pathmap("%z") } end def test_pattern_returns_substitutions assert_equal "bin/org/osb", "src/org/osb/Xyz.java".pathmap("%{src,bin}d") end def test_pattern_can_use_backreferences assert_equal "dir/hi/is", "dir/this/is".pathmap("%{t(hi)s,\\1}p") end def test_pattern_with_star_replacement_string_uses_block assert_equal "src/ORG/osb", "src/org/osb/Xyz.java".pathmap("%{/org,*}d") { |d| d.upcase } assert_equal "Xyz.java", "src/org/osb/Xyz.java".pathmap("%{.*,*}f") { |f| f.capitalize } end def test_pattern_with_no_replacement_nor_block_substitutes_empty_string assert_equal "bc.rb", "abc.rb".pathmap("%{a}f") end def test_pattern_works_with_certain_valid_operators assert_equal "dir/xbc.rb", "dir/abc.rb".pathmap("%{a,x}p") assert_equal "d1r", "dir/abc.rb".pathmap("%{i,1}d") assert_equal "xbc.rb", "dir/abc.rb".pathmap("%{a,x}f") assert_equal ".Rb", "dir/abc.rb".pathmap("%{r,R}x") assert_equal "xbc", "dir/abc.rb".pathmap("%{a,x}n") end def test_multiple_patterns assert_equal "this/is/b/directory/abc.rb", "this/is/a/dir/abc.rb".pathmap("%{a,b;dir,\\0ectory}p") end def test_partial_directory_selection_works_with_patterns assert_equal "this/is/a/long", "this/is/a/really/long/path/ok.rb".pathmap("%{/really/,/}5d") end def test_pattern_with_invalid_operator ex = assert_raises(ArgumentError) do "abc.xyz".pathmap("%{src,bin}z") end assert_match(/unknown.*pathmap.*spec.*z/i, ex.message) end def test_works_with_windows_separators if File::ALT_SEPARATOR assert_equal "abc", 'dir\abc.rb'.pathmap("%n") assert_equal 'this\is\a\dir', 'this\is\a\dir\abc.rb'.pathmap("%d") end end def test_complex_patterns sep = "".pathmap("%s") assert_equal "dir/abc.rb", "dir/abc.rb".pathmap("%d/%n%x") assert_equal "./abc.rb", "abc.rb".pathmap("%d/%n%x") assert_equal "Your file extension is '.rb'", "dir/abc.rb".pathmap("Your file extension is '%x'") assert_equal "bin/org/onstepback/proj/A.class", "src/org/onstepback/proj/A.java".pathmap("%{src,bin}d/%n.class") assert_equal "src_work/bin/org/onstepback/proj/A.class", "src_work/src/org/onstepback/proj/A.java".pathmap('%{\bsrc\b,bin}X.class') assert_equal ".depends.bak", ".depends".pathmap("%X.bak") assert_equal "d#{sep}a/b/c#{sep}file.txt", "a/b/c/d/file.txt".pathmap("%-1d%s%3d%s%f") end end rake-10.0.4/test/test_rake_task_with_arguments.rb0000644000004100000410000000737512124115317022206 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakeTaskWithArguments < Rake::TestCase include Rake def setup super Task.clear Rake::TaskManager.record_task_metadata = true end def teardown Rake::TaskManager.record_task_metadata = false super 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_args_and_prereqs t = task(:t, [:x, :y] => [:pre]) assert_equal "t", t.name assert_equal [:x, :y], t.arg_names assert_equal ["pre"], t.prerequisites 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 t.invoke(1) 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 task(:pre, :rev) { |t, args| value = args.rev } t = task(:t, [:name, :rev] => [:pre]) t.invoke("bill", "1.2") assert_equal "1.2", value end def test_args_not_passed_if_no_prereq_names_on_task task(:pre) { |t, args| assert_equal({}, args.to_hash) assert_equal "bill", args.name } t = task(:t, [:name, :rev] => [:pre]) t.invoke("bill", "1.2") end def test_args_not_passed_if_no_prereq_names_on_multitask task(:pre) { |t, args| assert_equal({}, args.to_hash) assert_equal "bill", args.name } t = multitask(:t, [:name, :rev] => [:pre]) t.invoke("bill", "1.2") end def test_args_not_passed_if_no_arg_names task(:pre, :rev) { |t, args| assert_equal({}, args.to_hash) } t = task(:t => [:pre]) t.invoke("bill", "1.2") end def test_values_at t = task(:pre, [:a, :b, :c]) { |task, args| a, b, c = args.values_at(:a, :b, :c) assert_equal %w[1 2 3], [a, b, c] } t.invoke(*%w[1 2 3]) # HACK no assertions end end rake-10.0.4/test/test_rake_early_time.rb0000644000004100000410000000132412124115317020242 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakeEarlyTime < Rake::TestCase def test_create early = Rake::EarlyTime.instance assert early <= Time.now assert early < Time.now assert early != Time.now assert Time.now > early assert Time.now >= early assert Time.now != early end def test_equality early = Rake::EarlyTime.instance assert_equal early, early, "two early times should be equal" end def test_original_time_compare_is_not_messed_up t1 = Time.mktime(1970, 1, 1, 0, 0, 0) t2 = Time.now assert t1 < t2 assert t2 > t1 assert t1 == t1 assert t2 == t2 end def test_to_s assert_equal "", Rake::EARLY.to_s end end rake-10.0.4/test/test_rake_task_arguments.rb0000644000004100000410000000464512124115317021150 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) ###################################################################### class TestRakeTaskArguments < Rake::TestCase def teardown ENV.delete('rev') ENV.delete('VER') super end def test_empty_arg_list_is_empty ta = Rake::TaskArguments.new([], []) assert_equal({}, ta.to_hash) end def test_multiple_values_in_args ta = Rake::TaskArguments.new([:a, :b, :c], [:one, :two, :three]) assert_equal({:a => :one, :b => :two, :c => :three}, ta.to_hash) end def test_to_s ta = Rake::TaskArguments.new([:a, :b, :c], [1, 2, 3]) assert_equal ta.to_hash.inspect, ta.to_s assert_equal ta.to_hash.inspect, ta.inspect end def test_enumerable_behavior ta = Rake::TaskArguments.new([:a, :b, :c], [1, 2 ,3]) assert_equal [10, 20, 30], ta.collect { |k,v| v * 10 }.sort end def test_named_args ta = Rake::TaskArguments.new(["aa", "bb"], [1, 2]) assert_equal 1, ta.aa assert_equal 1, ta[:aa] assert_equal 1, ta["aa"] assert_equal 2, ta.bb assert_nil ta.cc end def test_args_knows_its_names ta = Rake::TaskArguments.new(["aa", "bb"], [1, 2]) assert_equal ["aa", "bb"], ta.names end def test_extra_names_are_nil ta = Rake::TaskArguments.new(["aa", "bb", "cc"], [1, 2]) assert_nil ta.cc end def test_args_do_not_reference_env_values ta = Rake::TaskArguments.new(["aa"], [1]) ENV['rev'] = "1.2" ENV['VER'] = "2.3" assert_nil ta.rev assert_nil ta.ver end def test_creating_new_argument_scopes parent = Rake::TaskArguments.new(['p'], [1]) child = parent.new_scope(['c', 'p']) assert_equal({:p=>1}, child.to_hash) assert_equal 1, child.p assert_equal 1, child["p"] assert_equal 1, child[:p] assert_nil child.c end def test_child_hides_parent_arg_names parent = Rake::TaskArguments.new(['aa'], [1]) child = Rake::TaskArguments.new(['aa'], [2], parent) assert_equal 2, child.aa end def test_default_arguments_values_can_be_merged ta = Rake::TaskArguments.new(["aa", "bb"], [nil, "original_val"]) ta.with_defaults({ :aa => 'default_val' }) assert_equal 'default_val', ta[:aa] assert_equal 'original_val', ta[:bb] end def test_default_arguments_that_dont_match_names_are_ignored ta = Rake::TaskArguments.new(["aa", "bb"], [nil, "original_val"]) ta.with_defaults({ "cc" => "default_val" }) assert_nil ta[:cc] end end rake-10.0.4/test/test_thread_history_display.rb0000644000004100000410000000426712124115317021674 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'rake/thread_history_display' class TestThreadHistoryDisplay < Rake::TestCase def setup super @time = 1000000 @stats = [] @display = Rake::ThreadHistoryDisplay.new(@stats) end def test_banner out, _ = capture_io do @display.show end assert_match(/Job History/i, out) end def test_item_queued @stats << event(:item_queued, :item_id => 123) out, _ = capture_io do @display.show end assert_match(/^ *1000000 +A +item_queued +item_id:1$/, out) end def test_item_dequeued @stats << event(:item_dequeued, :item_id => 123) out, _ = capture_io do @display.show end assert_match(/^ *1000000 +A +item_dequeued +item_id:1$/, out) end def test_multiple_items @stats << event(:item_queued, :item_id => 123) @stats << event(:item_queued, :item_id => 124) out, _ = capture_io do @display.show end assert_match(/^ *1000000 +A +item_queued +item_id:1$/, out) assert_match(/^ *1000001 +A +item_queued +item_id:2$/, out) end def test_waiting @stats << event(:waiting, :item_id => 123) out, _ = capture_io do @display.show end assert_match(/^ *1000000 +A +waiting +item_id:1$/, out) end def test_continue @stats << event(:continue, :item_id => 123) out, _ = capture_io do @display.show end assert_match(/^ *1000000 +A +continue +item_id:1$/, out) end def test_thread_deleted @stats << event(:thread_deleted, :deleted_thread => 123456, :thread_count => 12) out, _ = capture_io do @display.show end assert_match(/^ *1000000 +A +thread_deleted( +deleted_thread:B| +thread_count:12){2}$/, out) end def test_thread_created @stats << event(:thread_created, :new_thread => 123456, :thread_count => 13) out, _ = capture_io do @display.show end assert_match(/^ *1000000 +A +thread_created( +new_thread:B| +thread_count:13){2}$/, out) end private def event(type, data={}) result = { :event => type, :time => @time / 1_000_000.0, :data => data, :thread => Thread.current.object_id } @time += 1 result end end rake-10.0.4/test/test_trace_output.rb0000644000004100000410000000215612124115317017630 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'stringio' class TestTraceOutput < Rake::TestCase include Rake::TraceOutput class PrintSpy attr_reader :result, :calls def initialize @result = "" @calls = 0 end def print(string) @result << string @calls += 1 end end def test_trace_issues_single_io_for_args_with_empty_args spy = PrintSpy.new trace_on(spy) assert_equal "\n", spy.result assert_equal 1, spy.calls end def test_trace_issues_single_io_for_args_multiple_strings spy = PrintSpy.new trace_on(spy, "HI\n", "LO") assert_equal "HI\nLO\n", spy.result assert_equal 1, spy.calls end def test_trace_handles_nil_objects spy = PrintSpy.new trace_on(spy, "HI\n", nil, "LO") assert_equal "HI\nLO\n", spy.result assert_equal 1, spy.calls end def test_trace_issues_single_io_for_args_multiple_strings_and_alternate_sep old_sep = $\ $\ = "\r" spy = PrintSpy.new trace_on(spy, "HI\r", "LO") assert_equal "HI\rLO\r", spy.result assert_equal 1, spy.calls ensure $\ = old_sep end end rake-10.0.4/test/test_rake.rb0000644000004100000410000000175212124115317016035 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRake < Rake::TestCase def test_each_dir_parent assert_equal ['a'], alldirs('a') assert_equal ['a/b', 'a'], alldirs('a/b') assert_equal ['/a/b', '/a', '/'], alldirs('/a/b') if File.dirname("c:/foo") == "c:" # Under Unix assert_equal ['c:/a/b', 'c:/a', 'c:'], alldirs('c:/a/b') assert_equal ['c:a/b', 'c:a'], alldirs('c:a/b') else # Under Windows assert_equal ['c:/a/b', 'c:/a', 'c:/'], alldirs('c:/a/b') assert_equal ['c:a/b', 'c:a'], alldirs('c:a/b') end end def alldirs(fn) result = [] Rake.each_dir_parent(fn) { |d| result << d } result end def test_can_override_application old_app = Rake.application fake_app = Object.new Rake.application = fake_app assert_equal fake_app, Rake.application ensure Rake.application = old_app end def test_original_dir_reports_current_dir assert_equal @tempdir, Rake.original_dir end end rake-10.0.4/test/test_rake_backtrace.rb0000644000004100000410000000413212124115317020027 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'open3' class TestRakeBacktrace < Rake::TestCase def setup super skip 'tmpdir is suppressed in backtrace' if Dir.pwd =~ Rake::Backtrace::SUPPRESS_PATTERN end # TODO: factor out similar code in test_rake_functional.rb def rake(*args) Open3.popen3(RUBY, "-I", @rake_lib, @rake_exec, *args) { |_, _, err, _| err.read } end def invoke(task_name) rake task_name.to_s end def test_single_collapse rakefile %q{ task :foo do raise "foooo!" end } lines = invoke(:foo).split("\n") assert_equal "rake aborted!", lines[0] assert_equal "foooo!", lines[1] assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:3!i, lines assert_something_matches %r!\ATasks:!, lines end def test_multi_collapse rakefile %q{ task :foo do Rake.application.invoke_task(:bar) end task :bar do raise "barrr!" end } lines = invoke(:foo).split("\n") assert_equal "rake aborted!", lines[0] assert_equal "barrr!", lines[1] assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:6!i, lines assert_something_matches %r!\A#{Regexp.quote Dir.pwd}/Rakefile:3!i, lines assert_something_matches %r!\ATasks:!, lines end def test_suppress_option rakefile %q{ task :baz do raise "bazzz!" end } lines = rake("baz").split("\n") assert_equal "rake aborted!", lines[0] assert_equal "bazzz!", lines[1] assert_something_matches %r!Rakefile!i, lines lines = rake("--suppress-backtrace", ".ak.file", "baz").split("\n") assert_equal "rake aborted!", lines[0] assert_equal "bazzz!", lines[1] refute_match %r!Rakefile!i, lines[2] end private # Assert that the pattern matches at least one line in +lines+. def assert_something_matches(pattern, lines) lines.each do |ln| if pattern =~ ln assert_match pattern, ln return end end flunk "expected #{pattern.inspect} to match something in:\n #{lines.join("\n ")}" end end rake-10.0.4/test/test_rake_task_manager.rb0000644000004100000410000000760112124115317020550 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakeTaskManager < Rake::TestCase def setup super @tm = Rake::TestCase::TaskManager.new end def test_create_task_manager refute_nil @tm assert_equal [], @tm.tasks end def test_define_task t = @tm.define_task(Rake::Task, :t) assert_equal "t", t.name assert_equal @tm, t.application end def test_index e = assert_raises RuntimeError do @tm['bad'] end assert_equal "Don't know how to build task 'bad'", e.message end def test_name_lookup t = @tm.define_task(Rake::Task, :t) assert_equal t, @tm[:t] end def test_namespace_task_create @tm.in_namespace("x") do t = @tm.define_task(Rake::Task, :t) assert_equal "x:t", t.name end assert_equal ["x:t"], @tm.tasks.collect { |t| t.name } end def test_anonymous_namespace anon_ns = @tm.in_namespace(nil) do t = @tm.define_task(Rake::Task, :t) assert_equal "_anon_1:t", t.name end task = anon_ns[:t] assert_equal "_anon_1:t", task.name end def test_create_filetask_in_namespace @tm.in_namespace("x") do t = @tm.define_task(Rake::FileTask, "fn") assert_equal "fn", t.name end assert_equal ["fn"], @tm.tasks.collect { |t| t.name } end def test_namespace_yields_same_namespace_as_returned yielded_namespace = nil returned_namespace = @tm.in_namespace("x") do |ns| yielded_namespace = ns end assert_equal returned_namespace, yielded_namespace end def test_name_lookup_with_implicit_file_tasks FileUtils.touch 'README.rdoc' t = @tm["README.rdoc"] assert_equal "README.rdoc", t.name assert Rake::FileTask === t end def test_name_lookup_with_nonexistent_task assert_raises(RuntimeError) { @tm["DOES NOT EXIST"] } end def test_name_lookup_in_multiple_scopes aa = nil bb = nil xx = @tm.define_task(Rake::Task, :xx) top_z = @tm.define_task(Rake::Task, :z) @tm.in_namespace("a") do aa = @tm.define_task(Rake::Task, :aa) mid_z = @tm.define_task(Rake::Task, :z) @tm.in_namespace("b") do bb = @tm.define_task(Rake::Task, :bb) bot_z = @tm.define_task(Rake::Task, :z) assert_equal ["a", "b"], @tm.current_scope assert_equal bb, @tm["a:b:bb"] assert_equal aa, @tm["a:aa"] assert_equal xx, @tm["xx"] assert_equal bot_z, @tm["z"] assert_equal mid_z, @tm["^z"] assert_equal top_z, @tm["^^z"] assert_equal top_z, @tm["rake:z"] end assert_equal ["a"], @tm.current_scope assert_equal bb, @tm["a:b:bb"] assert_equal aa, @tm["a:aa"] assert_equal xx, @tm["xx"] assert_equal bb, @tm["b:bb"] assert_equal aa, @tm["aa"] assert_equal mid_z, @tm["z"] assert_equal top_z, @tm["^z"] assert_equal top_z, @tm["rake:z"] end assert_equal [], @tm.current_scope assert_equal [], xx.scope assert_equal ['a'], aa.scope assert_equal ['a', 'b'], bb.scope end def test_lookup_with_explicit_scopes t1, t2, t3, s = (0...4).collect { nil } t1 = @tm.define_task(Rake::Task, :t) @tm.in_namespace("a") do t2 = @tm.define_task(Rake::Task, :t) s = @tm.define_task(Rake::Task, :s) @tm.in_namespace("b") do t3 = @tm.define_task(Rake::Task, :t) end end assert_equal t1, @tm[:t, []] assert_equal t2, @tm[:t, ["a"]] assert_equal t3, @tm[:t, ["a", "b"]] assert_equal s, @tm[:s, ["a", "b"]] assert_equal s, @tm[:s, ["a"]] end def test_correctly_scoped_prerequisites_are_invoked values = [] @tm = Rake::Application.new @tm.define_task(Rake::Task, :z) do values << "top z" end @tm.in_namespace("a") do @tm.define_task(Rake::Task, :z) do values << "next z" end @tm.define_task(Rake::Task, :x => :z) end @tm["a:x"].invoke assert_equal ["next z"], values end end rake-10.0.4/test/test_rake_application.rb0000644000004100000410000003035712124115317020423 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakeApplication < Rake::TestCase def setup super @app = Rake.application @app.options.rakelib = [] end def test_display_tasks @app.options.show_tasks = :tasks @app.options.show_task_pattern = // @app.last_description = "COMMENT" @app.define_task(Rake::Task, "t") out, = capture_io 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 @app.terminal_columns = 80 @app.options.show_tasks = :tasks @app.options.show_task_pattern = // @app.last_description = "1234567890" * 8 @app.define_task(Rake::Task, "t") out, = capture_io do @app.instance_eval { display_tasks_and_comments } end assert_match(/^rake t/, out) assert_match(/# 12345678901234567890123456789012345678901234567890123456789012345\.\.\./, out) end def test_display_tasks_with_task_name_wider_than_tty_display @app.terminal_columns = 80 @app.options.show_tasks = :tasks @app.options.show_task_pattern = // task_name = "task name" * 80 @app.last_description = "something short" @app.define_task(Rake::Task, task_name ) out, = capture_io 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 def test_display_tasks_with_very_long_task_name_to_a_non_tty_shows_name_and_comment @app.options.show_tasks = :tasks @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_io 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_tasks = :tasks @app.options.show_task_pattern = // @app.tty_output = false @app.last_description = "1234567890" * 8 @app.define_task(Rake::Task, "t") out, = capture_io 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 @app.terminal_columns = 80 @app.options.show_tasks = :tasks @app.options.show_task_pattern = // @app.tty_output = false @app.last_description = "1234567890" * 8 @app.define_task(Rake::Task, "t") out, = capture_io do @app.instance_eval { display_tasks_and_comments } end assert_match(/^rake t/, out) assert_match(/# 12345678901234567890123456789012345678901234567890123456789012345\.\.\./, out) end def test_describe_tasks @app.options.show_tasks = :describe @app.options.show_task_pattern = // @app.last_description = "COMMENT" @app.define_task(Rake::Task, "t") out, = capture_io do @app.instance_eval { display_tasks_and_comments } end assert_match(/^rake t$/, out) assert_match(/^ {4}COMMENT$/, out) end def test_show_lines @app.options.show_tasks = :lines @app.options.show_task_pattern = // @app.last_description = "COMMENT" @app.define_task(Rake::Task, "t") @app['t'].locations << "HERE:1" out, = capture_io do @app.instance_eval { display_tasks_and_comments } end assert_match(/^rake t +[^:]+:\d+ *$/, out) end def test_finding_rakefile rakefile_default 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 rakefile_unittest @app.instance_eval do handle_options options.silent = true load_rakefile end assert_equal "rakefile", @app.rakefile.downcase assert_equal @tempdir, Dir.pwd end def test_load_rakefile_doesnt_print_rakefile_directory_from_same_dir rakefile_unittest _, err = capture_io do @app.instance_eval do # pretend we started from the unittest dir @original_dir = File.expand_path(".") raw_load_rakefile end end assert_empty err end def test_load_rakefile_from_subdir rakefile_unittest Dir.chdir 'subdir' @app.instance_eval do handle_options options.silent = true load_rakefile end assert_equal "rakefile", @app.rakefile.downcase assert_equal @tempdir, Dir.pwd end def test_load_rakefile_prints_rakefile_directory_from_subdir rakefile_unittest Dir.chdir 'subdir' app = Rake::Application.new app.options.rakelib = [] _, err = capture_io do app.instance_eval do raw_load_rakefile end end assert_equal "(in #{@tempdir}\)\n", err end def test_load_rakefile_doesnt_print_rakefile_directory_from_subdir_if_silent rakefile_unittest Dir.chdir 'subdir' _, err = capture_io do @app.instance_eval do handle_options options.silent = true raw_load_rakefile end end assert_empty err end def test_load_rakefile_not_found Dir.chdir @tempdir ENV['RAKE_SYSTEM'] = 'not_exist' @app.instance_eval do handle_options options.silent = true end ex = assert_raises(RuntimeError) do @app.instance_eval do raw_load_rakefile end end assert_match(/no rakefile found/i, ex.message) end def test_load_from_system_rakefile rake_system_dir @app.instance_eval do handle_options options.silent = true options.load_system = true options.rakelib = [] load_rakefile end assert_equal @system_dir, @app.system_dir assert_nil @app.rakefile rescue SystemExit flunk 'failed to load rakefile' end def test_load_from_calculated_system_rakefile rakefile_default def @app.standard_system_dir "__STD_SYS_DIR__" end ENV['RAKE_SYSTEM'] = nil @app.instance_eval do handle_options options.silent = true options.load_system = true options.rakelib = [] load_rakefile end assert_equal "__STD_SYS_DIR__", @app.system_dir rescue SystemExit flunk 'failed to find system rakefile' end def test_terminal_columns old_RAKE_COLUMNS = ENV['RAKE_COLUMNS'] ENV['RAKE_COLUMNS'] = '42' app = Rake::Application.new assert_equal 42, app.terminal_columns ensure if old_RAKE_COLUMNS then ENV['RAKE_COLUMNS'].delete else ENV['RAKE_COLUMNS'] = old_RAKE_COLUMNS end end def test_windows assert ! (@app.windows? && @app.unix?) end def test_loading_imports loader = util_loader @app.instance_eval do add_loader("dummy", loader) add_import("x.dummy") load_imports end # HACK no assertions end def test_building_imported_files_on_demand loader = util_loader @app.instance_eval do intern(Rake::Task, "x.dummy").enhance do loader.make_dummy end add_loader("dummy", loader) add_import("x.dummy") load_imports end # HACK no assertions 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_handle_options_trace_default_is_stderr ARGV.clear ARGV << "--trace" @app.handle_options assert_equal STDERR, @app.options.trace_output assert @app.options.trace end def test_handle_options_trace_overrides_to_stdout ARGV.clear ARGV << "--trace=stdout" @app.handle_options assert_equal STDOUT, @app.options.trace_output assert @app.options.trace end def test_handle_options_trace_does_not_eat_following_task_names assert !@app.options.trace ARGV.clear ARGV << "--trace" << "sometask" @app.handle_options assert ARGV.include?("sometask") assert @app.options.trace end def test_good_run ran = false ARGV << '--rakelib=""' @app.options.silent = true @app.instance_eval do intern(Rake::Task, "default").enhance { ran = true } end rakefile_default out, err = capture_io do @app.run end assert ran assert_empty err assert_equal "DEFAULT\n", out 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_io { @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_io { @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_raises(SystemExit) { _, err = capture_io { @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_raises(SystemExit) { _, err = capture_io { @app.run } refute_match(/see full trace/, err) } ensure ARGV.clear end def test_bad_run_with_backtrace @app.intern(Rake::Task, "default").enhance { fail } ARGV.clear ARGV << '-f' << '-s' << '--backtrace' assert_raises(SystemExit) { _, err = capture_io { @app.run } refute_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_raises(SystemExit) { capture_io { @app.run } } ensure ARGV.clear end def test_standard_exception_handling_invalid_option out, err = capture_io do e = assert_raises SystemExit do @app.standard_exception_handling do raise OptionParser::InvalidOption, 'blah' end end assert_equal 1, e.status end assert_empty out assert_equal "invalid option: blah\n", err end def test_standard_exception_handling_other out, err = capture_io do e = assert_raises SystemExit do @app.standard_exception_handling do raise 'blah' end end assert_equal 1, e.status end assert_empty out assert_match "rake aborted!\n", err assert_match "blah\n", err end def test_standard_exception_handling_system_exit out, err = capture_io do e = assert_raises SystemExit do @app.standard_exception_handling do exit 0 end end assert_equal 0, e.status end assert_empty out assert_empty err end def test_standard_exception_handling_system_exit_nonzero out, err = capture_io do e = assert_raises SystemExit do @app.standard_exception_handling do exit 5 end end assert_equal 5, e.status end assert_empty out assert_empty err end def util_loader loader = Object.new loader.instance_variable_set :@load_called, false def loader.load arg raise 'called more than once' if @load_called raise ArgumentError, arg unless arg == 'x.dummy' @load_called = true end loader.instance_variable_set :@make_dummy_called, false def loader.make_dummy raise 'called more than once' if @make_dummy_called @make_dummy_called = true end loader end end rake-10.0.4/test/test_rake_task_argument_parsing.rb0000644000004100000410000000444112124115317022502 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakeTaskArgumentParsing < Rake::TestCase def setup super @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 def test_terminal_width_using_env app = Rake::Application.new app.terminal_columns = 1234 assert_equal 1234, app.terminal_width end def test_terminal_width_using_stty def @app.unix?() true end def @app.dynamic_width_stty() 1235 end def @app.dynamic_width_tput() 0 end assert_equal 1235, @app.terminal_width end def test_terminal_width_using_tput def @app.unix?() true end def @app.dynamic_width_stty() 0 end def @app.dynamic_width_tput() 1236 end assert_equal 1236, @app.terminal_width end def test_terminal_width_using_hardcoded_80 def @app.unix?() false end assert_equal 80, @app.terminal_width end def test_terminal_width_with_failure def @app.unix?() raise end assert_equal 80, @app.terminal_width end def test_no_rakeopt ARGV << '--trace' app = Rake::Application.new app.init assert !app.options.silent end def test_rakeopt_with_blank_options ARGV << '--trace' app = Rake::Application.new app.init assert !app.options.silent end def test_rakeopt_with_silent_options ENV['RAKEOPT'] = '-s' app = Rake::Application.new app.init assert app.options.silent end end rake-10.0.4/test/test_rake_task_manager_argument_resolution.rb0000644000004100000410000000113312124115317024727 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakeTaskManagerArgumentResolution < Rake::TestCase def test_good_arg_patterns assert_equal [:t, [], []], task(:t) assert_equal [:t, [], [:x]], task(:t => :x) assert_equal [:t, [], [:x, :y]], task(:t => [:x, :y]) assert_equal [:t, [:a, :b], []], task(:t, [:a, :b]) assert_equal [:t, [:a, :b], [:x]], task(:t, [:a, :b] => :x) assert_equal [:t, [:a, :b], [:x, :y]], task(:t, [:a, :b] => [:x, :y]) end def task(*args) tm = Rake::TestCase::TaskManager.new tm.resolve_args(args) end end rake-10.0.4/test/test_rake_package_task.rb0000644000004100000410000000362312124115317020531 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'rake/packagetask' class TestRakePackageTask < Rake::TestCase def test_initialize touch 'install.rb' touch 'a.c' touch 'b.c' mkdir 'CVS' touch 'a.rb~' pkg = Rake::PackageTask.new("pkgr", "1.2.3") { |p| p.package_files << "install.rb" p.package_files.include '*.c' p.package_files.exclude(/\bCVS\b/) p.package_files.exclude(/~$/) p.package_dir = 'pkg' p.need_tar = true p.need_tar_gz = true p.need_tar_bz2 = true p.need_zip = true } assert_equal "pkg", pkg.package_dir assert_includes pkg.package_files, 'a.c' assert_equal 'pkgr', pkg.name assert_equal '1.2.3', pkg.version assert Rake::Task[:package] assert Rake::Task['pkg/pkgr-1.2.3.tgz'] assert Rake::Task['pkg/pkgr-1.2.3.tar.gz'] assert Rake::Task['pkg/pkgr-1.2.3.tar.bz2'] assert Rake::Task['pkg/pkgr-1.2.3.zip'] assert Rake::Task['pkg/pkgr-1.2.3'] assert Rake::Task[:clobber_package] assert Rake::Task[:repackage] end def test_initialize_no_version e = assert_raises RuntimeError do Rake::PackageTask.new 'pkgr' end assert_equal 'Version required (or :noversion)', e.message end def test_initialize_noversion pkg = Rake::PackageTask.new 'pkgr', :noversion assert_equal 'pkg', pkg.package_dir assert_equal 'pkgr', pkg.name assert_equal nil, pkg.version end def test_clone pkg = Rake::PackageTask.new("x", :noversion) p2 = pkg.clone pkg.package_files << "y" p2.package_files << "x" assert_equal ["y"], pkg.package_files assert_equal ["x"], p2.package_files end def test_package_name pkg = Rake::PackageTask.new 'a', '1' assert_equal 'a-1', pkg.package_name end def test_package_name_noversion pkg = Rake::PackageTask.new 'a', :noversion assert_equal 'a', pkg.package_name end end rake-10.0.4/test/helper.rb0000644000004100000410000002373012124115317015333 0ustar www-datawww-datarequire 'rubygems' $:.unshift File.expand_path('../../lib', __FILE__) begin gem 'minitest' rescue Gem::LoadError end require 'minitest/autorun' require 'rake' require 'tmpdir' require File.expand_path('../file_creation', __FILE__) begin require_relative '../ruby/envutil' rescue NoMethodError, LoadError # for ruby trunk end class Rake::TestCase < MiniTest::Unit::TestCase include FileCreation include Rake::DSL class TaskManager include Rake::TaskManager end RUBY = defined?(EnvUtil) ? EnvUtil.rubybin : Gem.ruby def setup ARGV.clear test_dir = File.basename File.dirname File.expand_path __FILE__ @rake_root = if test_dir == 'test' then # rake repository File.expand_path '../../', __FILE__ else # ruby repository File.expand_path '../../../', __FILE__ end @rake_exec = File.join @rake_root, 'bin', 'rake' @rake_lib = File.join @rake_root, 'lib' @orig_PWD = Dir.pwd @orig_APPDATA = ENV['APPDATA'] @orig_HOME = ENV['HOME'] @orig_HOMEDRIVE = ENV['HOMEDRIVE'] @orig_HOMEPATH = ENV['HOMEPATH'] @orig_RAKE_COLUMNS = ENV['RAKE_COLUMNS'] @orig_RAKE_SYSTEM = ENV['RAKE_SYSTEM'] @orig_RAKEOPT = ENV['RAKEOPT'] @orig_USERPROFILE = ENV['USERPROFILE'] ENV.delete 'RAKE_COLUMNS' ENV.delete 'RAKE_SYSTEM' ENV.delete 'RAKEOPT' tmpdir = Dir.chdir Dir.tmpdir do Dir.pwd end @tempdir = File.join tmpdir, "test_rake_#{$$}" FileUtils.mkdir_p @tempdir Dir.chdir @tempdir Rake.application = Rake::Application.new Rake::TaskManager.record_task_metadata = true RakeFileUtils.verbose_flag = false end def teardown Dir.chdir @orig_PWD FileUtils.rm_rf @tempdir if @orig_APPDATA then ENV['APPDATA'] = @orig_APPDATA else ENV.delete 'APPDATA' end ENV['HOME'] = @orig_HOME ENV['HOMEDRIVE'] = @orig_HOMEDRIVE ENV['HOMEPATH'] = @orig_HOMEPATH ENV['RAKE_COLUMNS'] = @orig_RAKE_COLUMNS ENV['RAKE_SYSTEM'] = @orig_RAKE_SYSTEM ENV['RAKEOPT'] = @orig_RAKEOPT ENV['USERPROFILE'] = @orig_USERPROFILE end def ignore_deprecations Rake.application.options.ignore_deprecate = true yield ensure Rake.application.options.ignore_deprecate = false end def rake_system_dir @system_dir = 'system' FileUtils.mkdir_p @system_dir open File.join(@system_dir, 'sys1.rake'), 'w' do |io| io << <<-SYS task "sys1" do puts "SYS1" end SYS end ENV['RAKE_SYSTEM'] = @system_dir end def rakefile contents open 'Rakefile', 'w' do |io| io << contents end end def rakefile_access rakefile <<-ACCESS TOP_LEVEL_CONSTANT = 0 def a_top_level_function end task :default => [:work, :obj, :const] task :work do begin a_top_level_function puts "GOOD:M Top level methods can be called in tasks" rescue NameError => ex puts "BAD:M Top level methods can not be called in tasks" end end # TODO: remove `disabled_' when DeprecatedObjectDSL removed task :obj task :disabled_obj do begin Object.new.instance_eval { task :xyzzy } puts "BAD:D Rake DSL are polluting objects" rescue StandardError => ex puts "GOOD:D Rake DSL are not polluting objects" end end task :const do begin TOP_LEVEL_CONSTANT puts "GOOD:C Top level constants are available in tasks" rescue StandardError => ex puts "BAD:C Top level constants are NOT available in tasks" end end ACCESS end def rakefile_chains rakefile <<-DEFAULT task :default => "play.app" file "play.scpt" => "base" do |t| cp t.prerequisites.first, t.name end rule ".app" => ".scpt" do |t| cp t.source, t.name end file 'base' do touch 'base' end DEFAULT end def rakefile_comments rakefile <<-COMMENTS # comment for t1 task :t1 do end # no comment or task because there's a blank line task :t2 do end desc "override comment for t3" # this is not the description multitask :t3 do end # this is not the description desc "override comment for t4" file :t4 do end COMMENTS end def rakefile_default rakefile <<-DEFAULT if ENV['TESTTOPSCOPE'] puts "TOPSCOPE" end task :default do puts "DEFAULT" end task :other => [:default] do puts "OTHER" end task :task_scope do if ENV['TESTTASKSCOPE'] puts "TASKSCOPE" end end DEFAULT end def rakefile_dryrun rakefile <<-DRYRUN task :default => ["temp_main"] file "temp_main" => [:all_apps] do touch "temp_main" end task :all_apps => [:one, :two] task :one => ["temp_one"] task :two => ["temp_two"] file "temp_one" do |t| touch "temp_one" end file "temp_two" do |t| touch "temp_two" end task :clean do ["temp_one", "temp_two", "temp_main"].each do |file| rm_f file end end DRYRUN FileUtils.touch 'temp_main' FileUtils.touch 'temp_two' end def rakefile_extra rakefile 'task :default' FileUtils.mkdir_p 'rakelib' open File.join('rakelib', 'extra.rake'), 'w' do |io| io << <<-EXTRA_RAKE # Added for testing namespace :extra do desc "An Extra Task" task :extra do puts "Read all about it" end end EXTRA_RAKE end end def rakefile_file_creation rakefile <<-'FILE_CREATION' N = 2 task :default => :run BUILD_DIR = 'build' task :clean do rm_rf 'build' rm_rf 'src' end task :run TARGET_DIR = 'build/copies' FileList['src/*'].each do |src| directory TARGET_DIR target = File.join TARGET_DIR, File.basename(src) file target => [src, TARGET_DIR] do cp src, target # sleep 3 if src !~ /foo#{N-1}$/ # I'm commenting out this sleep, it doesn't seem to do anything. end task :run => target end task :prep => :clean do mkdir_p 'src' N.times do |n| touch "src/foo#{n}" end end FILE_CREATION end def rakefile_imports rakefile <<-IMPORTS require 'rake/loaders/makefile' task :default task :other do puts "OTHER" end file "dynamic_deps" do |t| open(t.name, "w") do |f| f.puts "puts 'DYNAMIC'" end end import "dynamic_deps" import "static_deps" import "static_deps" import "deps.mf" puts "FIRST" IMPORTS open 'deps.mf', 'w' do |io| io << <<-DEPS default: other DEPS end open "static_deps", "w" do |f| f.puts 'puts "STATIC"' end end def rakefile_multidesc rakefile <<-MULTIDESC task :b desc "A" task :a desc "B" task :b desc "A2" task :a task :c desc "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" task :d MULTIDESC end def rakefile_namespace rakefile <<-NAMESPACE desc "copy" task :copy do puts "COPY" end namespace "nest" do desc "nest copy" task :copy do puts "NEST COPY" end task :xx => :copy end anon_ns = namespace do desc "anonymous copy task" task :copy do puts "ANON COPY" end end desc "Top level task to run the anonymous version of copy" task :anon => anon_ns[:copy] namespace "very" do namespace "nested" do task "run" => "rake:copy" end end namespace "a" do desc "Run task in the 'a' namespace" task "run" do puts "IN A" end end namespace "b" do desc "Run task in the 'b' namespace" task "run" => "a:run" do puts "IN B" end end namespace "file1" do file "xyz.rb" do puts "XYZ1" end end namespace "file2" do file "xyz.rb" do puts "XYZ2" end end namespace "scopedep" do task :prepare do touch "scopedep.rb" puts "PREPARE" end file "scopedep.rb" => [:prepare] do puts "SCOPEDEP" end end NAMESPACE end def rakefile_nosearch FileUtils.touch 'dummy' end def rakefile_rakelib FileUtils.mkdir_p 'rakelib' Dir.chdir 'rakelib' do open 'test1.rb', 'w' do |io| io << <<-TEST1 task :default do puts "TEST1" end TEST1 end open 'test2.rake', 'w' do |io| io << <<-TEST1 task :default do puts "TEST2" end TEST1 end end end def rakefile_rbext open 'rakefile.rb', 'w' do |io| io << 'task :default do puts "OK" end' end end def rakefile_unittest rakefile '# Empty Rakefile for Unit Test' readme = File.join 'subdir', 'README' FileUtils.mkdir_p File.dirname readme FileUtils.touch readme end def rakefile_verbose rakefile <<-VERBOSE task :standalone_verbose_true do verbose true sh "#{RUBY} -e '0'" end task :standalone_verbose_false do verbose false sh "#{RUBY} -e '0'" end task :inline_verbose_default do sh "#{RUBY} -e '0'" end task :inline_verbose_false do sh "#{RUBY} -e '0'", :verbose => false end task :inline_verbose_true do sh "#{RUBY} -e '0'", :verbose => true end task :block_verbose_true do verbose(true) do sh "#{RUBY} -e '0'" end end task :block_verbose_false do verbose(false) do sh "#{RUBY} -e '0'" end end VERBOSE end def rakefile_test_signal rakefile <<-TEST_SIGNAL require 'rake/testtask' Rake::TestTask.new(:a) do |t| t.test_files = ['a_test.rb'] end Rake::TestTask.new(:b) do |t| t.test_files = ['b_test.rb'] end task :test do Rake::Task[:a].invoke Rake::Task[:b].invoke end task :default => :test TEST_SIGNAL open 'a_test.rb', 'w' do |io| io << 'puts "ATEST"' << "\n" io << '$stdout.flush' << "\n" io << 'Process.kill("TERM", $$)' << "\n" end open 'b_test.rb', 'w' do |io| io << 'puts "BTEST"' << "\n" io << '$stdout.flush' << "\n" end end def rakefile_failing_test_task rakefile <<-TEST_TASK require 'rake/testtask' task :default => :test Rake::TestTask.new(:test) do |t| t.test_files = ['a_test.rb'] end TEST_TASK open 'a_test.rb', 'w' do |io| io << "require 'minitest/autorun'\n" io << "class ExitTaskTest < MiniTest::Unit::TestCase\n" io << " def test_exit\n" io << " assert false, 'this should fail'\n" io << " end\n" io << "end\n" end end def rakefile_stand_alone_filelist open 'stand_alone_filelist.rb', 'w' do |io| io << "require 'rake/file_list'\n" io << "FL = Rake::FileList['*.rb']\n" io << "puts FL\n" end end end rake-10.0.4/test/test_rake_functional.rb0000644000004100000410000002337712124115317020266 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'fileutils' require 'open3' class TestRakeFunctional < Rake::TestCase def setup super @ruby_options = ["-I#{@rake_lib}", "-I."] @verbose = ENV['VERBOSE'] if @verbose puts puts puts '-' * 80 puts @__name__ puts '-' * 80 end end def test_rake_default rakefile_default rake assert_match(/^DEFAULT$/, @out) end def test_rake_error_on_bad_task rakefile_default rake '-t', 'xyz' assert_match(/rake aborted/, @err) end def test_env_available_at_top_scope rakefile_default rake "TESTTOPSCOPE=1" assert_match(/^TOPSCOPE$/, @out) end def test_env_available_at_task_scope rakefile_default rake 'TESTTASKSCOPE=1', 'task_scope' assert_match(/^TASKSCOPE$/, @out) end def test_multi_desc ENV['RAKE_COLUMNS'] = '80' rakefile_multidesc rake "-T" assert_match %r{^rake a *# A / A2 *$}, @out assert_match %r{^rake b *# B *$}, @out refute_match %r{^rake c}, @out assert_match %r{^rake d *# x{65}\.\.\.$}, @out end def test_long_description rakefile_multidesc rake "--describe" 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 refute_match %r{^rake c\n}m, @out end def test_proper_namespace_access rakefile_access rake refute_match %r{^BAD:}, @out end def test_rbext rakefile_rbext rake "-N" assert_match %r{^OK$}, @out end def test_system rake_system_dir rake '-g', "sys1" assert_match %r{^SYS1}, @out end def test_system_excludes_rakelib_files_too rake_system_dir rake '-g', "sys1", '-T', 'extra' refute_match %r{extra:extra}, @out end def test_by_default_rakelib_files_are_included rake_system_dir rakefile_extra rake '-T', 'extra', '--trace' assert_match %r{extra:extra}, @out end def test_implicit_system rake_system_dir Dir.chdir @tempdir rake "sys1", "--trace" assert_match %r{^SYS1}, @out end def test_no_system rake_system_dir rakefile_extra rake '-G', "sys1" assert_match %r{^Don't know how to build task}, @err # emacs wart: ' end def test_nosearch_with_rakefile_uses_local_rakefile rakefile_default rake "--nosearch" assert_match %r{^DEFAULT}, @out end def test_nosearch_without_rakefile_finds_system rakefile_nosearch rake_system_dir rake "--nosearch", "sys1" assert_match %r{^SYS1}, @out end def test_nosearch_without_rakefile_and_no_system_fails rakefile_nosearch ENV['RAKE_SYSTEM'] = 'not_exist' rake "--nosearch" assert_match %r{^No Rakefile found}, @err end def test_invalid_command_line_options rakefile_default rake "--bad-options" assert_match %r{invalid +option}i, @err end def test_inline_verbose_default_should_show_command rakefile_verbose rake "inline_verbose_default" assert_match(/#{Regexp.quote(RUBY)} -e/, @err) end def test_inline_verbose_true_should_show_command rakefile_verbose rake "inline_verbose_true" assert_match(/#{Regexp.quote(RUBY)} -e/, @err) end def test_inline_verbose_false_should_not_show_command rakefile_verbose rake "inline_verbose_false" refute_match(/#{Regexp.quote(RUBY)} -e/, @err) end def test_block_verbose_false_should_not_show_command rakefile_verbose rake "block_verbose_false" refute_match(/#{Regexp.quote(RUBY)} -e/, @err) end def test_block_verbose_true_should_show_command rakefile_verbose rake "block_verbose_true" assert_match(/#{Regexp.quote(RUBY)} -e/, @err) end def test_standalone_verbose_true_should_show_command rakefile_verbose rake "standalone_verbose_true" assert_match(/#{Regexp.quote(RUBY)} -e/, @err) end def test_standalone_verbose_false_should_not_show_command rakefile_verbose rake "standalone_verbose_false" refute_match(/#{Regexp.quote(RUBY)} -e/, @err) end def test_dry_run rakefile_default rake "-n", "other" assert_match %r{Execute \(dry run\) default}, @err assert_match %r{Execute \(dry run\) other}, @err refute_match %r{DEFAULT}, @out refute_match %r{OTHER}, @out end # Test for the trace/dry_run bug found by Brian Chandler def test_dry_run_bug rakefile_dryrun rake FileUtils.rm_f 'temp_one' rake "--dry-run" refute_match(/No such file/, @out) end # Test for the trace/dry_run bug found by Brian Chandler def test_trace_bug rakefile_dryrun rake FileUtils.rm_f 'temp_one' rake "--trace" refute_match(/No such file/, @out) end def test_imports rakefile_imports rake assert File.exist?(File.join(@tempdir, 'dynamic_deps')), "'dynamic_deps' file should exist" assert_match(/^FIRST$\s+^DYNAMIC$\s+^STATIC$\s+^OTHER$/, @out) end def test_rules_chaining_to_file_task rakefile_chains rake assert File.exist?(File.join(@tempdir, 'play.app')), "'play.app' file should exist" end def test_file_creation_task rakefile_file_creation rake "prep" rake "run" rake "run" assert(@err !~ /^cp src/, "Should not recopy data") end def test_dash_f_with_no_arg_foils_rakefile_lookup rakefile_rakelib rake '-I', 'rakelib', '-rtest1', '-f' assert_match(/^TEST1$/, @out) end def test_dot_rake_files_can_be_loaded_with_dash_r rakefile_rakelib rake '-I', 'rakelib', '-rtest2', '-f' assert_empty @err assert_match(/^TEST2$/, @out) end def test_can_invoke_task_in_toplevel_namespace rakefile_namespace rake "copy" assert_match(/^COPY$/, @out) end def test_can_invoke_task_in_nested_namespace rakefile_namespace rake "nest:copy" assert_match(/^NEST COPY$/, @out) end def test_tasks_can_reference_task_in_same_namespace rakefile_namespace rake "nest:xx" assert_match(/^NEST COPY$/m, @out) end def test_tasks_can_reference_task_in_other_namespaces rakefile_namespace rake "b:run" assert_match(/^IN A\nIN B$/m, @out) end def test_anonymous_tasks_can_be_invoked_indirectly rakefile_namespace rake "anon" assert_match(/^ANON COPY$/m, @out) end def test_rake_namespace_refers_to_toplevel rakefile_namespace rake "very:nested:run" assert_match(/^COPY$/m, @out) end def test_file_task_are_not_scoped_by_namespaces rakefile_namespace rake "xyz.rb" assert_match(/^XYZ1\nXYZ2$/m, @out) end def test_file_task_dependencies_scoped_by_namespaces rakefile_namespace rake "scopedep.rb" assert_match(/^PREPARE\nSCOPEDEP$/m, @out) end def test_comment_before_task_acts_like_desc rakefile_comments rake "-T" refute_match(/comment for t1/, @out) end def test_comment_separated_from_task_by_blank_line_is_not_picked_up rakefile_comments rake "-T" refute_match("t2", @out) end def test_comment_after_desc_is_ignored rakefile_comments rake "-T" assert_match("override comment for t3", @out) end def test_comment_before_desc_is_ignored rakefile_comments rake "-T" assert_match("override comment for t4", @out) end def test_correct_number_of_tasks_reported rakefile_comments rake "-T" assert_equal(2, @out.split(/\n/).grep(/t\d/).size) end def test_file_list_is_requirable_separately ruby '-rrake/file_list', '-e', 'puts Rake::FileList["a"].size' assert_equal "1\n", @out end def can_detect_signals? system "ruby -e 'Process.kill \"TERM\", $$'" status = $? if @verbose puts " SIG status = #{$?.inspect}" puts " SIG status.respond_to?(:signaled?) = #{$?.respond_to?(:signaled?).inspect}" puts " SIG status.signaled? = #{status.signaled?}" if status.respond_to?(:signaled?) end status.respond_to?(:signaled?) && status.signaled? end def test_signal_propagation_in_tests if can_detect_signals? rakefile_test_signal rake assert_match(/ATEST/, @out) refute_match(/BTEST/, @out) else skip "Signal detect seems broken on this system" end end def test_failing_test_sets_exit_status skip if uncertain_exit_status? rakefile_failing_test_task rake assert @exit.exitstatus > 0, "should be non-zero" end def test_stand_alone_filelist rakefile_stand_alone_filelist run_ruby @ruby_options + ["stand_alone_filelist.rb"] assert_match(/^stand_alone_filelist\.rb$/, @out) assert_equal 0, @exit.exitstatus unless uncertain_exit_status? end private # We are unable to accurately verify that Rake returns a proper # error exit status using popen3 in Ruby 1.8.7 and JRuby. This # predicate function can be used to skip tests or assertions as # needed. def uncertain_exit_status? RUBY_VERSION < "1.9" || defined?(JRUBY_VERSION) end # Run a shell Ruby command with command line options (using the # default test options). Output is captured in @out and @err def ruby(*option_list) run_ruby(@ruby_options + option_list) end # Run a command line rake with the give rake options. Default # command line ruby options are included. Output is captured in # @out and @err def rake(*rake_options) run_ruby @ruby_options + [@rake_exec] + rake_options end # Low level ruby command runner ... def run_ruby(option_list) puts "COMMAND: [#{RUBY} #{option_list.join ' '}]" if @verbose inn, out, err, wait = Open3.popen3(RUBY, *option_list) inn.close @exit = wait ? wait.value : $? @out = out.read @err = err.read puts "OUTPUT: [#{@out}]" if @verbose puts "ERROR: [#{@err}]" if @verbose puts "EXIT: [#{@exit.inspect}]" if @verbose puts "PWD: [#{Dir.pwd}]" if @verbose end end rake-10.0.4/test/test_rake_rules.rb0000644000004100000410000001764412124115317017256 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'fileutils' class TestRakeRules < Rake::TestCase include Rake SRCFILE = "abc.c" SRCFILE2 = "xyz.c" FTNFILE = "abc.f" OBJFILE = "abc.o" FOOFILE = "foo" DOTFOOFILE = ".foo" def setup super Task.clear @runs = [] end def test_multiple_rules1 create_file(FTNFILE) delete_file(SRCFILE) delete_file(OBJFILE) rule(/\.o$/ => ['.c']) do @runs << :C end rule(/\.o$/ => ['.f']) do @runs << :F end t = Task[OBJFILE] t.invoke Task[OBJFILE].invoke assert_equal [:F], @runs end def test_multiple_rules2 create_file(FTNFILE) delete_file(SRCFILE) delete_file(OBJFILE) rule(/\.o$/ => ['.f']) do @runs << :F end rule(/\.o$/ => ['.c']) do @runs << :C end Task[OBJFILE].invoke assert_equal [:F], @runs end def test_create_with_source create_file(SRCFILE) rule(/\.o$/ => ['.c']) do |t| @runs << t.name assert_equal OBJFILE, t.name assert_equal SRCFILE, t.source end Task[OBJFILE].invoke assert_equal [OBJFILE], @runs end def test_single_dependent create_file(SRCFILE) rule(/\.o$/ => '.c') do |t| @runs << t.name end Task[OBJFILE].invoke assert_equal [OBJFILE], @runs end def test_rule_can_be_created_by_string create_file(SRCFILE) rule '.o' => ['.c'] do |t| @runs << t.name end Task[OBJFILE].invoke assert_equal [OBJFILE], @runs end def test_rule_prereqs_can_be_created_by_string create_file(SRCFILE) rule '.o' => '.c' do |t| @runs << t.name end Task[OBJFILE].invoke assert_equal [OBJFILE], @runs end def test_plain_strings_as_dependents_refer_to_files create_file(SRCFILE) rule '.o' => SRCFILE do |t| @runs << t.name end Task[OBJFILE].invoke assert_equal [OBJFILE], @runs end def test_file_names_beginning_with_dot_can_be_tricked_into_referring_to_file verbose(false) do create_file('.foo') rule '.o' => "./.foo" do |t| @runs << t.name end Task[OBJFILE].invoke assert_equal [OBJFILE], @runs end end def test_file_names_beginning_with_dot_can_be_wrapped_in_lambda verbose(false) do create_file(".foo") rule '.o' => lambda{".foo"} do |t| @runs << "#{t.name} - #{t.source}" end Task[OBJFILE].invoke assert_equal ["#{OBJFILE} - .foo"], @runs end end def test_file_names_containing_percent_can_be_wrapped_in_lambda verbose(false) do create_file("foo%x") rule '.o' => lambda{"foo%x"} do |t| @runs << "#{t.name} - #{t.source}" end Task[OBJFILE].invoke assert_equal ["#{OBJFILE} - foo%x"], @runs end end def test_non_extension_rule_name_refers_to_file verbose(false) do create_file("abc.c") rule "abc" => '.c' do |t| @runs << t.name end Task["abc"].invoke assert_equal ["abc"], @runs end end def test_pathmap_automatically_applies_to_name verbose(false) do create_file("zzabc.c") rule ".o" => 'zz%{x,a}n.c' do |t| @runs << "#{t.name} - #{t.source}" end Task["xbc.o"].invoke assert_equal ["xbc.o - zzabc.c"], @runs end end def test_plain_strings_are_just_filenames verbose(false) do create_file("plainname") rule ".o" => 'plainname' do |t| @runs << "#{t.name} - #{t.source}" end Task["xbc.o"].invoke assert_equal ["xbc.o - plainname"], @runs end end def test_rule_runs_when_explicit_task_has_no_actions create_file(SRCFILE) create_file(SRCFILE2) delete_file(OBJFILE) rule '.o' => '.c' do |t| @runs << t.source end file OBJFILE => [SRCFILE2] Task[OBJFILE].invoke assert_equal [SRCFILE], @runs end def test_close_matches_on_name_do_not_trigger_rule create_file("x.c") rule '.o' => ['.c'] do |t| @runs << t.name end assert_raises(RuntimeError) { Task['x.obj'].invoke } assert_raises(RuntimeError) { Task['x.xyo'].invoke } end def test_rule_rebuilds_obj_when_source_is_newer create_timed_files(OBJFILE, SRCFILE) rule(/\.o$/ => ['.c']) do @runs << :RULE end Task[OBJFILE].invoke assert_equal [:RULE], @runs end def test_rule_with_two_sources_runs_if_both_sources_are_present create_timed_files(OBJFILE, SRCFILE, SRCFILE2) rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do @runs << :RULE end Task[OBJFILE].invoke assert_equal [:RULE], @runs end def test_rule_with_two_sources_but_one_missing_does_not_run create_timed_files(OBJFILE, SRCFILE) delete_file(SRCFILE2) rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do @runs << :RULE end Task[OBJFILE].invoke assert_equal [], @runs end def test_rule_with_two_sources_builds_both_sources task 'x.aa' task 'x.bb' rule '.a' => '.aa' do @runs << "A" end rule '.b' => '.bb' do @runs << "B" end rule ".c" => ['.a', '.b'] do @runs << "C" end Task["x.c"].invoke assert_equal ["A", "B", "C"], @runs.sort end def test_second_rule_runs_when_first_rule_doesnt create_timed_files(OBJFILE, SRCFILE) delete_file(SRCFILE2) rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do @runs << :RULE1 end rule OBJFILE => [lambda{SRCFILE}] do @runs << :RULE2 end Task[OBJFILE].invoke assert_equal [:RULE2], @runs end def test_second_rule_doest_run_if_first_triggers create_timed_files(OBJFILE, SRCFILE, SRCFILE2) rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do @runs << :RULE1 end rule OBJFILE => [lambda{SRCFILE}] do @runs << :RULE2 end Task[OBJFILE].invoke assert_equal [:RULE1], @runs end def test_second_rule_doest_run_if_first_triggers_with_reversed_rules create_timed_files(OBJFILE, SRCFILE, SRCFILE2) rule OBJFILE => [lambda{SRCFILE}] do @runs << :RULE1 end rule OBJFILE => [lambda{SRCFILE}, lambda{SRCFILE2}] do @runs << :RULE2 end Task[OBJFILE].invoke assert_equal [:RULE1], @runs end def test_rule_with_proc_dependent_will_trigger mkdir_p("src/jw") create_file("src/jw/X.java") rule %r(classes/.*\.class) => [ proc { |fn| fn.pathmap("%{classes,src}d/%n.java") } ] do |task| assert_equal task.name, 'classes/jw/X.class' assert_equal task.source, 'src/jw/X.java' @runs << :RULE end Task['classes/jw/X.class'].invoke assert_equal [:RULE], @runs ensure rm_r("src", :verbose=>false) rescue nil end def test_proc_returning_lists_are_flattened_into_prereqs ran = false mkdir_p("flatten") create_file("flatten/a.txt") task 'flatten/b.data' do |t| ran = true touch t.name, :verbose => false end rule '.html' => proc { |fn| [ fn.ext("txt"), "flatten/b.data" ] } do |task| end Task['flatten/a.html'].invoke assert ran, "Should have triggered flattened dependency" ensure rm_r("flatten", :verbose=>false) rescue nil end def test_recursive_rules_will_work_as_long_as_they_terminate actions = [] create_file("abc.xml") rule '.y' => '.xml' do actions << 'y' end rule '.c' => '.y' do actions << 'c'end rule '.o' => '.c' do actions << 'o'end rule '.exe' => '.o' do actions << 'exe'end Task["abc.exe"].invoke assert_equal ['y', 'c', 'o', 'exe'], actions end def test_recursive_rules_that_dont_terminate_will_overflow create_file("a.a") prev = 'a' ('b'..'z').each do |letter| rule ".#{letter}" => ".#{prev}" do |t| puts "#{t.name}" end prev = letter end ex = assert_raises(Rake::RuleRecursionOverflowError) { Task["a.z"].invoke } assert_match(/a\.z => a.y/, ex.message) end def test_rules_with_bad_dependents_will_fail rule "a" => [ 1 ] do |t| puts t.name end assert_raises(RuntimeError) do Task['a'].invoke end end end rake-10.0.4/test/file_creation.rb0000644000004100000410000000145312124115317016655 0ustar www-datawww-datamodule FileCreation OLDFILE = "old" NEWFILE = "new" def create_timed_files(oldfile, *newfiles) return if (File.exist?(oldfile) && newfiles.all? { |newfile| File.exist?(newfile) && File.stat(newfile).mtime > File.stat(oldfile).mtime }) now = Time.now create_file(oldfile, now - 60) newfiles.each do |newfile| create_file(newfile, now) end end def create_dir(dirname) FileUtils.mkdir_p(dirname) unless File.exist?(dirname) File.stat(dirname).mtime end def create_file(name, file_time=nil) create_dir(File.dirname(name)) FileUtils.touch(name) unless File.exist?(name) File.utime(file_time, file_time, name) unless file_time.nil? File.stat(name).mtime end def delete_file(name) File.delete(name) rescue nil end end rake-10.0.4/test/test_rake_file_list.rb0000644000004100000410000003711112124115317020065 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakeFileList < Rake::TestCase FileList = Rake::FileList def setup super FileUtils.mkdir "CVS" rescue nil FileUtils.mkdir ".svn" rescue nil @cdir = "cfiles" FileUtils.mkdir @cdir rescue nil FileUtils.touch ".dummy" FileUtils.touch "x.bak" FileUtils.touch "x~" FileUtils.touch "core" FileUtils.touch "x.c" FileUtils.touch "xyz.c" FileUtils.touch "abc.c" FileUtils.touch "abc.h" FileUtils.touch "abc.x" FileUtils.touch "existing" open 'xyzzy.txt', 'w' do |io| io.puts 'x' io.puts 'XYZZY' end end def test_delegating_methods_do_not_include_to_a_or_to_ary assert ! FileList::DELEGATING_METHODS.include?("to_a"), "should not include to_a" assert ! FileList::DELEGATING_METHODS.include?(:to_a), "should not include to_a" assert ! FileList::DELEGATING_METHODS.include?("to_ary"), "should not include to_ary" assert ! FileList::DELEGATING_METHODS.include?(:to_ary), "should not include to_ary" end def test_create fl = FileList.new assert_equal 0, fl.size end def test_create_with_args fl = FileList.new("*.c", "x") assert_equal ["abc.c", "x.c", "xyz.c", "x"].sort, fl.sort end def test_create_with_block fl = FileList.new { |f| f.include("x") } assert_equal ["x"], fl.resolve end def test_create_with_brackets fl = FileList["*.c", "x"] assert_equal ["abc.c", "x.c", "xyz.c", "x"].sort, fl.sort end def test_create_with_brackets_and_filelist fl = FileList[FileList["*.c", "x"]] assert_equal ["abc.c", "x.c", "xyz.c", "x"].sort, fl.sort end def test_include_with_another_array fl = FileList.new.include(["x", "y", "z"]) assert_equal ["x", "y", "z"].sort, fl.sort end def test_include_with_another_filelist fl = FileList.new.include(FileList["*.c", "x"]) assert_equal ["abc.c", "x.c", "xyz.c", "x"].sort, fl.sort end def test_append fl = FileList.new fl << "a.rb" << "b.rb" assert_equal ['a.rb', 'b.rb'], fl end def test_add_many fl = FileList.new fl.include %w(a d c) fl.include('x', 'y') assert_equal ['a', 'd', 'c', 'x', 'y'], fl assert_equal ['a', 'd', 'c', 'x', 'y'], fl.resolve end def test_add_return f = FileList.new g = f << "x" assert_equal f.object_id, g.object_id h = f.include("y") assert_equal f.object_id, h.object_id end def test_match fl = FileList.new fl.include '*.c' assert_equal %w[abc.c x.c xyz.c], fl.sort end def test_add_matching fl = FileList.new fl << "a.java" fl.include '*.c' assert_equal %w[a.java abc.c x.c xyz.c], fl.sort end def test_multiple_patterns fl = FileList.new fl.include('*.z', '*foo*') assert_equal [], fl fl.include('*.c', '*xist*') assert_equal %w[x.c xyz.c abc.c existing].sort, fl.sort end def test_square_bracket_pattern fl = FileList.new fl.include("abc.[ch]") assert fl.size == 2 assert fl.include?("abc.c") assert fl.include?("abc.h") end def test_curly_bracket_pattern fl = FileList.new fl.include("abc.{c,h}") assert fl.size == 2 assert fl.include?("abc.c") assert fl.include?("abc.h") end def test_reject fl = FileList.new fl.include %w(x.c abc.c xyz.c existing) fl.reject! { |fn| fn =~ /^x/ } assert_equal %w[abc.c existing], fl end def test_exclude fl = FileList['x.c', 'abc.c', 'xyz.c', 'existing'] fl.each { |fn| touch fn, :verbose => false } x = fl.exclude(%r{^x.+\.}) assert_equal FileList, x.class assert_equal %w(x.c abc.c existing), fl assert_equal fl.object_id, x.object_id fl.exclude('*.c') assert_equal ['existing'], fl fl.exclude('existing') assert_equal [], fl end def test_excluding_via_block fl = FileList['a.c', 'b.c', 'xyz.c'] fl.exclude { |fn| fn.pathmap('%n') == 'xyz' } assert fl.exclude?("xyz.c"), "Should exclude xyz.c" assert_equal ['a.c', 'b.c'], fl end def test_exclude_return_on_create fl = FileList['*'].exclude(/.*\.[hcx]$/) assert_equal %w[cfiles existing xyzzy.txt], fl.sort assert_equal FileList, fl.class end def test_exclude_with_string_return_on_create fl = FileList['*'].exclude('abc.c') assert_equal %w[abc.h abc.x cfiles existing x.c xyz.c xyzzy.txt], fl.sort assert_equal FileList, fl.class end def test_default_exclude fl = FileList.new fl.clear_exclude fl.include("**/*~", "**/*.bak", "**/core") assert fl.member?("core"), "Should include core" assert fl.member?("x.bak"), "Should include .bak files" end def test_unique fl = FileList.new fl << "x.c" << "a.c" << "b.rb" << "a.c" assert_equal ['x.c', 'a.c', 'b.rb', 'a.c'], fl fl.uniq! assert_equal ['x.c', 'a.c', 'b.rb'], fl end def test_to_string fl = FileList.new fl << "a.java" << "b.java" assert_equal "a.java b.java", fl.to_s assert_equal "a.java b.java", "#{fl}" end def test_to_array fl = FileList['a.java', 'b.java'] assert_equal ['a.java', 'b.java'], fl.to_a assert_equal Array, fl.to_a.class assert_equal ['a.java', 'b.java'], fl.to_ary assert_equal Array, fl.to_ary.class end def test_to_s_pending fl = FileList['abc.*'] result = fl.to_s assert_match(%r{abc\.c}, result) assert_match(%r{abc\.h}, result) assert_match(%r{abc\.x}, result) assert_match(%r{(abc\..\b ?){2}}, result) end def test_inspect_pending fl = FileList['abc.*'] result = fl.inspect assert_match(%r{"abc\.c"}, result) assert_match(%r{"abc\.h"}, result) assert_match(%r{"abc\.x"}, result) assert_match(%r|^\[("abc\..", ){2}"abc\.."\]$|, result) end def test_sub fl = FileList["*.c"] f2 = fl.sub(/\.c$/, ".o") assert_equal FileList, f2.class assert_equal ["abc.o", "x.o", "xyz.o"].sort, f2.sort f3 = fl.gsub(/\.c$/, ".o") assert_equal FileList, f3.class assert_equal ["abc.o", "x.o", "xyz.o"].sort, f3.sort end def test_claim_to_be_a_kind_of_array fl = FileList['*.c'] assert fl.is_a?(Array) assert fl.kind_of?(Array) end def test_claim_to_be_a_kind_of_filelist fl = FileList['*.c'] assert fl.is_a?(FileList) assert fl.kind_of?(FileList) end def test_claim_to_be_a_filelist_instance fl = FileList['*.c'] assert fl.instance_of?(FileList) end def test_dont_claim_to_be_an_array_instance fl = FileList['*.c'] assert ! fl.instance_of?(Array) end def test_sub! f = "x/a.c" fl = FileList[f, "x/b.c"] res = fl.sub!(/\.c$/, ".o") assert_equal ["x/a.o", "x/b.o"].sort, fl.sort assert_equal "x/a.c", f assert_equal fl.object_id, res.object_id end def test_sub_with_block fl = FileList["src/org/onestepback/a.java", "src/org/onestepback/b.java"] # The block version doesn't work the way I want it to ... # f2 = fl.sub(%r{^src/(.*)\.java$}) { |x| "classes/" + $1 + ".class" } f2 = fl.sub(%r{^src/(.*)\.java$}, "classes/\\1.class") assert_equal [ "classes/org/onestepback/a.class", "classes/org/onestepback/b.class" ].sort, f2.sort end def test_string_ext assert_equal "one.net", "one.two".ext("net") assert_equal "one.net", "one.two".ext(".net") assert_equal "one.net", "one".ext("net") assert_equal "one.net", "one".ext(".net") assert_equal "one.two.net", "one.two.c".ext(".net") assert_equal "one/two.net", "one/two.c".ext(".net") assert_equal "one.x/two.net", "one.x/two.c".ext(".net") assert_equal "one.x/two.net", "one.x/two".ext(".net") assert_equal ".onerc.net", ".onerc.dot".ext("net") assert_equal ".onerc.net", ".onerc".ext("net") assert_equal ".a/.onerc.net", ".a/.onerc".ext("net") assert_equal "one", "one.two".ext('') assert_equal "one", "one.two".ext assert_equal ".one", ".one.two".ext assert_equal ".one", ".one".ext assert_equal ".", ".".ext("c") assert_equal "..", "..".ext("c") # These only need to work in windows if Rake::Win32.windows? assert_equal "one.x\\two.net", "one.x\\two.c".ext(".net") assert_equal "one.x\\two.net", "one.x\\two".ext(".net") end end def test_filelist_ext assert_equal FileList['one.c', '.one.c'], FileList['one.net', '.one'].ext('c') end def test_gsub fl = FileList["*.c"] f2 = fl.gsub(/a/, "A") assert_equal ["Abc.c", "x.c", "xyz.c"].sort, f2.sort end def test_gsub! f = FileList["*.c"] f.gsub!(/a/, "A") assert_equal ["Abc.c", "x.c", "xyz.c"].sort, f.sort end def test_egrep_returns_0_if_no_matches files = FileList['test/lib/*_test.rb'].exclude("test/lib/filelist_test.rb") assert_equal 0, files.egrep(/XYZZY/) { } end def test_egrep_with_output files = FileList['*.txt'] out, = capture_io do files.egrep(/XYZZY/) end assert_equal "xyzzy.txt:2:XYZZY\n", out end def test_egrep_with_block files = FileList['*.txt'] found = nil files.egrep(/XYZZY/) do |fn, ln, line| found = [fn, ln, line] end assert_equal ["xyzzy.txt", 2, "XYZZY\n"], found end def test_egrep_with_error files = FileList['*.txt'] _, err = capture_io do files.egrep(/XYZZY/) do |fn, ln, line | raise "_EGREP_FAILURE_" end end assert_equal "Error while processing 'xyzzy.txt': _EGREP_FAILURE_\n", err end def test_existing fl = FileList['abc.c', 'notthere.c'] assert_equal ["abc.c"], fl.existing assert fl.existing.is_a?(FileList) end def test_existing! fl = FileList['abc.c', 'notthere.c'] result = fl.existing! assert_equal ["abc.c"], fl assert_equal fl.object_id, result.object_id end def test_ignore_special f = FileList['*'] assert ! f.include?("CVS"), "Should not contain CVS" assert ! f.include?(".svn"), "Should not contain .svn" assert ! f.include?(".dummy"), "Should not contain dot files" assert ! f.include?("x.bak"), "Should not contain .bak files" assert ! f.include?("x~"), "Should not contain ~ files" assert ! f.include?("core"), "Should not contain core files" end def test_clear_ignore_patterns f = FileList['*', '.svn'] f.clear_exclude assert f.include?("abc.c") assert f.include?("xyz.c") assert f.include?("CVS") assert f.include?(".svn") assert f.include?("x.bak") assert f.include?("x~") end def test_exclude_with_alternate_file_seps fl = FileList.new assert fl.exclude?("x/CVS/y") assert fl.exclude?("x\\CVS\\y") assert fl.exclude?("x/.svn/y") assert fl.exclude?("x\\.svn\\y") assert fl.exclude?("x/core") assert fl.exclude?("x\\core") end def test_add_default_exclude_list fl = FileList.new fl.exclude(/~\d+$/) assert fl.exclude?("x/CVS/y") assert fl.exclude?("x\\CVS\\y") assert fl.exclude?("x/.svn/y") assert fl.exclude?("x\\.svn\\y") assert fl.exclude?("x/core") assert fl.exclude?("x\\core") assert fl.exclude?("x/abc~1") end def test_basic_array_functions f = FileList['b', 'c', 'a'] assert_equal 'b', f.first assert_equal 'b', f[0] assert_equal 'a', f.last assert_equal 'a', f[2] assert_equal 'a', f[-1] assert_equal ['a', 'b', 'c'], f.sort f.sort! assert_equal ['a', 'b', 'c'], f end def test_flatten assert_equal ['a', 'x.c', 'xyz.c', 'abc.c'].sort, ['a', FileList['*.c']].flatten.sort end def test_clone_and_dup a = FileList['a', 'b', 'c'] c = a.clone d = a.dup a << 'd' assert_equal ['a', 'b', 'c', 'd'], a assert_equal ['a', 'b', 'c'], c assert_equal ['a', 'b', 'c'], d end def test_dup_and_clone_replicate_taint a = FileList['a', 'b', 'c'] a.taint c = a.clone d = a.dup assert c.tainted?, "Clone should be tainted" assert d.tainted?, "Dup should be tainted" end def test_duped_items_will_thaw a = FileList['a', 'b', 'c'] a.freeze d = a.dup d << 'more' assert_equal ['a', 'b', 'c', 'more'], d end def test_cloned_items_stay_frozen a = FileList['a', 'b', 'c'] a.freeze c = a.clone assert_raises(TypeError, RuntimeError) do c << 'more' end end def test_array_comparisons fl = FileList['b', 'b'] a = ['b', 'a'] b = ['b', 'b'] c = ['b', 'c'] assert_equal( 1, fl <=> a ) assert_equal( 0, fl <=> b ) assert_equal( -1, fl <=> c ) assert_equal( -1, a <=> fl ) assert_equal( 0, b <=> fl ) assert_equal( 1, c <=> fl ) end def test_array_equality a = FileList['a', 'b'] b = ['a', 'b'] assert a == b assert b == a # assert a.eql?(b) # assert b.eql?(a) assert ! a.equal?(b) assert ! b.equal?(a) end def test_enumeration_methods a = FileList['a', 'b'] b = a.collect { |it| it.upcase } assert_equal ['A', 'B'], b assert_equal FileList, b.class b = a.map { |it| it.upcase } assert_equal ['A', 'B'], b assert_equal FileList, b.class b = a.sort assert_equal ['a', 'b'], b assert_equal FileList, b.class b = a.sort_by { |it| it } assert_equal ['a', 'b'], b assert_equal FileList, b.class b = a.find_all { |it| it == 'b'} assert_equal ['b'], b assert_equal FileList, b.class b = a.select { |it| it.size == 1 } assert_equal ['a', 'b'], b assert_equal FileList, b.class b = a.reject { |it| it == 'b' } assert_equal ['a'], b assert_equal FileList, b.class b = a.grep(/./) assert_equal ['a', 'b'], b assert_equal FileList, b.class b = a.partition { |it| it == 'b' } assert_equal [['b'], ['a']], b assert_equal Array, b.class assert_equal FileList, b[0].class assert_equal FileList, b[1].class b = a.zip(['x', 'y']).to_a assert_equal [['a', 'x'], ['b', 'y']], b assert_equal Array, b.class assert_equal Array, b[0].class assert_equal Array, b[1].class end def test_array_operators a = ['a', 'b'] b = ['c', 'd'] f = FileList['x', 'y'] g = FileList['w', 'z'] r = f + g assert_equal ['x', 'y', 'w', 'z'], r assert_equal FileList, r.class r = a + g assert_equal ['a', 'b', 'w', 'z'], r assert_equal Array, r.class r = f + b assert_equal ['x', 'y', 'c', 'd'], r assert_equal FileList, r.class r = FileList['w', 'x', 'y', 'z'] - f assert_equal ['w', 'z'], r assert_equal FileList, r.class r = FileList['w', 'x', 'y', 'z'] & f assert_equal ['x', 'y'], r assert_equal FileList, r.class r = f * 2 assert_equal ['x', 'y', 'x', 'y'], r assert_equal FileList, r.class r = f * ',' assert_equal 'x,y', r assert_equal String, r.class r = f | ['a', 'x'] assert_equal ['a', 'x', 'y'].sort, r.sort assert_equal FileList, r.class end def test_other_array_returning_methods f = FileList['a', nil, 'b'] r = f.compact assert_equal ['a', 'b'], r assert_equal FileList, r.class f = FileList['a', 'b'] r = f.concat(['x', 'y']) assert_equal ['a', 'b', 'x', 'y'], r assert_equal FileList, r.class f = FileList['a', ['b', 'c'], FileList['d', 'e']] r = f.flatten assert_equal ['a', 'b', 'c', 'd', 'e'], r assert_equal FileList, r.class f = FileList['a', 'b', 'a'] r = f.uniq assert_equal ['a', 'b'], r assert_equal FileList, r.class f = FileList['a', 'b', 'c', 'd'] r = f.values_at(1,3) assert_equal ['b', 'd'], r assert_equal FileList, r.class end def test_file_utils_can_use_filelists cfiles = FileList['*.c'] cp cfiles, @cdir, :verbose => false assert File.exist?(File.join(@cdir, 'abc.c')) assert File.exist?(File.join(@cdir, 'xyz.c')) assert File.exist?(File.join(@cdir, 'x.c')) end end rake-10.0.4/test/test_rake_rake_test_loader.rb0000644000004100000410000000065712124115317021427 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakeRakeTestLoader < Rake::TestCase def test_pattern orig_LOADED_FEATURES = $:.dup FileUtils.touch 'foo.rb' FileUtils.touch 'test_a.rb' FileUtils.touch 'test_b.rb' ARGV.replace %w[foo.rb test_*.rb -v] load File.join(@rake_lib, 'rake/rake_test_loader.rb') assert_equal %w[-v], ARGV ensure $:.replace orig_LOADED_FEATURES end end rake-10.0.4/test/test_rake_application_options.rb0000644000004100000410000002736312124115317022201 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) TESTING_REQUIRE = [ ] class TestRakeApplicationOptions < Rake::TestCase def setup super clear_argv Rake::FileUtilsExt.verbose_flag = false Rake::FileUtilsExt.nowrite_flag = false TESTING_REQUIRE.clear end def teardown clear_argv Rake::FileUtilsExt.verbose_flag = false Rake::FileUtilsExt.nowrite_flag = false super end def clear_argv while ! ARGV.empty? ARGV.pop end end def test_default_options opts = command_line assert_nil opts.backtrace assert_nil opts.dryrun assert_nil opts.ignore_system assert_nil opts.load_system assert_nil opts.always_multitask 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_nil opts.thread_pool_size assert_equal ['rakelib'], opts.rakelib assert ! Rake::FileUtilsExt.verbose_flag assert ! Rake::FileUtilsExt.nowrite_flag end def test_dry_run flags('--dry-run', '-n') do |opts| assert opts.dryrun assert opts.trace assert Rake::FileUtilsExt.verbose_flag assert Rake::FileUtilsExt.nowrite_flag end end def test_describe flags('--describe') do |opts| assert_equal :describe, 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_equal :describe, 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 refute_equal :exit, @exit $xyzzy = 0 end end def test_execute_and_print $xyzzy = 0 out, = capture_io do flags('--execute-print=$xyzzy="pugh"', '-p $xyzzy="pugh"') do |opts| assert_equal 'pugh', $xyzzy assert_equal :exit, @exit $xyzzy = 0 end end assert_match(/^pugh$/, out) end def test_help out, = capture_io do flags '--help', '-H', '-h' end assert_match(/\Arake/, out) assert_match(/\boptions\b/, out) assert_match(/\btargets\b/, out) assert_equal :exit, @exit end def test_jobs flags(['--jobs', '4'], ['-j', '4']) do |opts| assert_equal 4, opts.thread_pool_size end flags(['--jobs', 'asdas'], ['-j', 'asdas']) do |opts| assert_equal 2, opts.thread_pool_size end flags('--jobs', '-j') do |opts| assert_equal 2, opts.thread_pool_size end end def test_libdir flags(['--libdir', 'xx'], ['-I', 'xx'], ['-Ixx']) do |opts| $:.include?('xx') end ensure $:.delete('xx') end def test_multitask flags('--multitask', '-m') do |opts| assert_equal opts.always_multitask, true end 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 dirs = %w(A B C).join(File::PATH_SEPARATOR) flags(['--rakelibdir', dirs], ["--rakelibdir=#{dirs}"], ['-R', dirs], ["-R#{dirs}"]) do |opts| assert_equal ['A', 'B', 'C'], opts.rakelib end end def test_require $LOAD_PATH.unshift @tempdir open 'reqfile.rb', 'w' do |io| io << 'TESTING_REQUIRE << 1' end open 'reqfile2.rb', 'w' do |io| io << 'TESTING_REQUIRE << 2' end open 'reqfile3.rake', 'w' do |io| io << 'TESTING_REQUIRE << 3' end flags(['--require', 'reqfile'], '-rreqfile2', '-rreqfile3') assert_includes TESTING_REQUIRE, 1 assert_includes TESTING_REQUIRE, 2 assert_includes TESTING_REQUIRE, 3 assert_equal 3, TESTING_REQUIRE.size ensure $LOAD_PATH.delete @tempdir end def test_missing_require ex = assert_raises(LoadError) do flags(['--require', 'test/missing']) do |opts| end end assert_match(/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 Rake::FileUtilsExt.verbose_flag = true flags('--quiet', '-q') do |opts| assert ! Rake::FileUtilsExt.verbose_flag, "verbose flag shoud be false" assert ! opts.silent, "should not be silent" end end def test_no_search flags('--nosearch', '--no-search', '-N') do |opts| assert opts.nosearch end end def test_silent Rake::FileUtilsExt.verbose_flag = true flags('--silent', '-s') do |opts| assert ! Rake::FileUtilsExt.verbose_flag, "verbose flag should be false" assert opts.silent, "should be 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, "should enable trace option" assert opts.backtrace, "should enabled backtrace option" assert_equal $stderr, opts.trace_output assert Rake::FileUtilsExt.verbose_flag assert ! Rake::FileUtilsExt.nowrite_flag end end def test_trace_with_stdout flags('--trace=stdout', '-tstdout') do |opts| assert opts.trace, "should enable trace option" assert opts.backtrace, "should enabled backtrace option" assert_equal $stdout, opts.trace_output assert Rake::FileUtilsExt.verbose_flag assert ! Rake::FileUtilsExt.nowrite_flag end end def test_trace_with_stderr flags('--trace=stderr', '-tstderr') do |opts| assert opts.trace, "should enable trace option" assert opts.backtrace, "should enabled backtrace option" assert_equal $stderr, opts.trace_output assert Rake::FileUtilsExt.verbose_flag assert ! Rake::FileUtilsExt.nowrite_flag end end def test_trace_with_error ex = assert_raises(Rake::CommandLineOptionError) do flags('--trace=xyzzy') do |opts| end end assert_match(/un(known|recognized).*\btrace\b.*xyzzy/i, ex.message) end def test_trace_with_following_task_name flags(['--trace', 'taskname'], ['-t', 'taskname']) do |opts| assert opts.trace, "should enable trace option" assert opts.backtrace, "should enabled backtrace option" assert_equal $stderr, opts.trace_output assert Rake::FileUtilsExt.verbose_flag assert_equal ['taskname'], @app.top_level_tasks end end def test_backtrace flags('--backtrace') do |opts| assert opts.backtrace, "should enable backtrace option" assert_equal $stderr, opts.trace_output assert ! opts.trace, "should not enable trace option" end end def test_backtrace_with_stdout flags('--backtrace=stdout') do |opts| assert opts.backtrace, "should enable backtrace option" assert_equal $stdout, opts.trace_output assert ! opts.trace, "should not enable trace option" end end def test_backtrace_with_stderr flags('--backtrace=stderr') do |opts| assert opts.backtrace, "should enable backtrace option" assert_equal $stderr, opts.trace_output assert ! opts.trace, "should not enable trace option" end end def test_backtrace_with_error ex = assert_raises(Rake::CommandLineOptionError) do flags('--backtrace=xyzzy') do |opts| end end assert_match(/un(known|recognized).*\bbacktrace\b.*xyzzy/i, ex.message) end def test_backtrace_with_following_task_name flags(['--backtrace', 'taskname']) do |opts| assert ! opts.trace, "should enable trace option" assert opts.backtrace, "should enabled backtrace option" assert_equal $stderr, opts.trace_output assert_equal ['taskname'], @app.top_level_tasks 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_equal :tasks, opts.show_tasks assert_equal(//.to_s, opts.show_task_pattern.to_s) assert_equal nil, opts.show_all_tasks end flags(['--tasks', 'xyz'], ['-Txyz']) do |opts| assert_equal :tasks, opts.show_tasks assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s) assert_equal nil, opts.show_all_tasks end flags(['--tasks', 'xyz', '--comments']) do |opts| assert_equal :tasks, opts.show_tasks assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s) assert_equal false, opts.show_all_tasks end end def test_where flags('--where', '-W') do |opts| assert_equal :lines, opts.show_tasks assert_equal(//.to_s, opts.show_task_pattern.to_s) assert_equal true, opts.show_all_tasks end flags(['--where', 'xyz'], ['-Wxyz']) do |opts| assert_equal :lines, opts.show_tasks assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s) assert_equal true, opts.show_all_tasks end flags(['--where', 'xyz', '--comments'], ['-Wxyz', '--comments']) do |opts| assert_equal :lines, opts.show_tasks assert_equal(/xyz/.to_s, opts.show_task_pattern.to_s) assert_equal false, opts.show_all_tasks end end def test_no_deprecated_messages flags('--no-deprecation-warnings', '-X') do |opts| assert opts.ignore_deprecate end end def test_verbose capture_io do flags('--verbose', '-v') do |opts| assert Rake::FileUtilsExt.verbose_flag, "verbose should be true" assert ! opts.silent, "opts should not be silent" end end end def test_version out, _ = capture_io do flags '--version', '-V' end assert_match(/\bversion\b/, out) assert_match(/\b#{RAKEVERSION}\b/, out) assert_equal :exit, @exit end def test_bad_option _, err = capture_io do ex = assert_raises(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 assert_equal '', err 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("TESTKEY=12") assert_equal '12', ENV['TESTKEY'] end def test_multiline_environment_definition ENV.delete('TESTKEY') command_line("TESTKEY=a\nb\n") assert_equal "a\nb\n", ENV['TESTKEY'] end def test_environment_and_tasks_together ENV.delete('TESTKEY') command_line("a", "b", "TESTKEY=12") assert_equal ["a", "b"], @tasks.sort assert_equal '12', ENV['TESTKEY'] end def test_rake_explicit_task_library Rake.add_rakelib 'app/task', 'other' libs = Rake.application.options.rakelib assert libs.include?("app/task") assert libs.include?("other") end private def flags(*sets) sets.each do |set| ARGV.clear @exit = catch(:system_exit) { 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 rake-10.0.4/test/test_rake_path_map_explode.rb0000644000004100000410000000200212124115317021413 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakePathMapExplode < Rake::TestCase def setup super String.class_eval { public :pathmap_explode } end def teardown String.class_eval { protected :pathmap_explode } super end def test_explode assert_equal ['a'], 'a'.pathmap_explode assert_equal ['a', 'b'], 'a/b'.pathmap_explode assert_equal ['a', 'b', 'c'], 'a/b/c'.pathmap_explode assert_equal ['/', 'a'], '/a'.pathmap_explode assert_equal ['/', 'a', 'b'], '/a/b'.pathmap_explode assert_equal ['/', 'a', 'b', 'c'], '/a/b/c'.pathmap_explode if File::ALT_SEPARATOR assert_equal ['c:.', 'a'], 'c:a'.pathmap_explode assert_equal ['c:.', 'a', 'b'], 'c:a/b'.pathmap_explode assert_equal ['c:.', 'a', 'b', 'c'], 'c:a/b/c'.pathmap_explode assert_equal ['c:/', 'a'], 'c:/a'.pathmap_explode assert_equal ['c:/', 'a', 'b'], 'c:/a/b'.pathmap_explode assert_equal ['c:/', 'a', 'b', 'c'], 'c:/a/b/c'.pathmap_explode end end end rake-10.0.4/test/test_rake_clean.rb0000644000004100000410000000057212124115317017176 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'rake/clean' class TestRakeClean < Rake::TestCase include Rake def test_clean load 'rake/clean.rb', true assert Task['clean'], "Should define clean" assert Task['clobber'], "Should define clobber" assert Task['clobber'].prerequisites.include?("clean"), "Clobber should require clean" end end rake-10.0.4/test/test_rake_multi_task.rb0000644000004100000410000000337712124115317020276 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'thread' class TestRakeMultiTask < Rake::TestCase include Rake include Rake::DSL def setup super Task.clear @runs = Array.new @mutex = Mutex.new end def add_run(obj) @mutex.synchronize do @runs << obj end end def test_running_multitasks task :a do 3.times do |i| add_run("A#{i}"); sleep 0.01; end end task :b do 3.times do |i| add_run("B#{i}"); sleep 0.01; end end multitask :both => [:a, :b] Task[:both].invoke assert_equal 6, @runs.size assert @runs.index("A0") < @runs.index("A1") assert @runs.index("A1") < @runs.index("A2") assert @runs.index("B0") < @runs.index("B1") assert @runs.index("B1") < @runs.index("B2") end def test_all_multitasks_wait_on_slow_prerequisites task :slow do 3.times do |i| add_run("S#{i}"); sleep 0.05 end end task :a => [:slow] do 3.times do |i| add_run("A#{i}"); sleep 0.01 end end task :b => [:slow] do 3.times do |i| add_run("B#{i}"); sleep 0.01 end end multitask :both => [:a, :b] Task[:both].invoke assert_equal 9, @runs.size assert @runs.index("S0") < @runs.index("S1") assert @runs.index("S1") < @runs.index("S2") assert @runs.index("S2") < @runs.index("A0") assert @runs.index("S2") < @runs.index("B0") assert @runs.index("A0") < @runs.index("A1") assert @runs.index("A1") < @runs.index("A2") assert @runs.index("B0") < @runs.index("B1") assert @runs.index("B1") < @runs.index("B2") end def test_multitasks_with_parameters task :a, [:arg] do |t,args| add_run(args[:arg]) end multitask :b, [:arg] => [:a] do |t,args| add_run(args[:arg]+'mt') end Task[:b].invoke "b" assert @runs[0] == "b" assert @runs[1] == "bmt" end end rake-10.0.4/test/test_rake_directory_task.rb0000644000004100000410000000271512124115317021143 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'fileutils' class TestRakeDirectoryTask < Rake::TestCase include Rake def test_directory desc "DESC" directory "a/b/c" assert_equal FileCreationTask, Task["a"].class assert_equal FileCreationTask, Task["a/b"].class assert_equal FileCreationTask, Task["a/b/c"].class assert_nil Task["a"].comment assert_nil Task["a/b"].comment assert_equal "DESC", Task["a/b/c"].comment verbose(false) { Task['a/b'].invoke } assert File.exist?("a/b") refute File.exist?("a/b/c") end if Rake::Win32.windows? def test_directory_win32 desc "WIN32 DESC" directory 'c:/a/b/c' assert_equal FileTask, Task['c:'].class assert_equal FileCreationTask, Task['c:/a'].class assert_equal FileCreationTask, Task['c:/a/b'].class assert_equal FileCreationTask, Task['c:/a/b/c'].class assert_nil Task['c:/'].comment assert_equal "WIN32 DESC", Task['c:/a/b/c'].comment assert_nil Task['c:/a/b'].comment end end def test_can_use_blocks runlist = [] t1 = directory("a/b/c" => :t2) { |t| runlist << t.name } task(:t2) { |t| runlist << t.name } verbose(false) { t1.invoke } assert_equal Task["a/b/c"], t1 assert_equal FileCreationTask, Task["a/b/c"].class assert_equal ["t2", "a/b/c"], runlist assert File.directory?("a/b/c") end end rake-10.0.4/test/test_rake_task_lib.rb0000644000004100000410000000031412124115317017676 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'rake/tasklib' class TestRakeTaskLib < Rake::TestCase def test_paste tl = Rake::TaskLib.new assert_equal :ab, tl.paste(:a, :b) end end rake-10.0.4/test/test_rake_makefile_loader.rb0000644000004100000410000000214012124115317021210 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'rake/loaders/makefile' class TestRakeMakefileLoader < Rake::TestCase include Rake def test_parse Dir.chdir @tempdir open 'sample.mf', 'w' do |io| io << <<-'SAMPLE_MF' # Comments a: a1 a2 a3 a4 b: b1 b2 b3 \ b4 b5 b6\ # Mid: Comment b7 a : a5 a6 a7 c: c1 d: d1 d2 \ e f : e1 f1 g\ 0: g1 g\ 2 g\ 3 g4 SAMPLE_MF end Task.clear loader = Rake::MakefileLoader.new loader.load 'sample.mf' %w(a b c d).each do |t| assert Task.task_defined?(t), "#{t} should be a defined task" end assert_equal %w(a1 a2 a3 a4 a5 a6 a7).sort, Task['a'].prerequisites.sort assert_equal %w(b1 b2 b3 b4 b5 b6 b7).sort, Task['b'].prerequisites.sort assert_equal %w(c1).sort, Task['c'].prerequisites.sort assert_equal %w(d1 d2).sort, Task['d'].prerequisites.sort assert_equal %w(e1 f1).sort, Task['e'].prerequisites.sort assert_equal %w(e1 f1).sort, Task['f'].prerequisites.sort assert_equal ["g1", "g 2", "g 3", "g4"].sort, Task['g 0'].prerequisites.sort assert_equal 7, Task.tasks.size end end rake-10.0.4/test/test_rake_extension.rb0000644000004100000410000000223712124115317020130 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'stringio' class TestRakeExtension < Rake::TestCase module Redirect def error_redirect old_err = $stderr result = StringIO.new $stderr = result yield result ensure $stderr = old_err end end class Sample extend Redirect def duplicate_method :original end OK_ERRS = error_redirect do rake_extension("a") do def ok_method end end end DUP_ERRS = error_redirect do rake_extension("duplicate_method") do def duplicate_method :override end end end end def test_methods_actually_exist sample = Sample.new sample.ok_method sample.duplicate_method end def test_no_warning_when_defining_ok_method assert_equal "", Sample::OK_ERRS.string end def test_extension_complains_when_a_method_that_is_present assert_match(/warning:/i, Sample::DUP_ERRS.string) assert_match(/already exists/i, Sample::DUP_ERRS.string) assert_match(/duplicate_method/i, Sample::DUP_ERRS.string) assert_equal :original, Sample.new.duplicate_method end end rake-10.0.4/test/test_rake_reduce_compat.rb0000644000004100000410000000125412124115317020724 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'open3' class TestRakeReduceCompat < Rake::TestCase # TODO: factor out similar code in test_rake_functional.rb def rake(*args) Open3.popen3(RUBY, "-I", @rake_lib, @rake_exec, *args) { |_, out, _, _| out.read } end def invoke_normal(task_name) rake task_name.to_s end def test_no_deprecated_dsl rakefile %q{ task :check_task do Module.new { p defined?(task) } end task :check_file do Module.new { p defined?(file) } end } assert_equal "nil", invoke_normal(:check_task).chomp assert_equal "nil", invoke_normal(:check_file).chomp end end rake-10.0.4/test/test_rake_definitions.rb0000644000004100000410000000353312124115317020427 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'fileutils' class TestRakeDefinitions < Rake::TestCase include Rake EXISTINGFILE = "existing" def setup super Task.clear end def test_task done = false task :one => [:two] do done = true end task :two task :three => [:one, :two] check_tasks(:one, :two, :three) assert done, "Should be done" end def test_file_task done = false file "one" => "two" do done = true end file "two" file "three" => ["one", "two"] check_tasks("one", "two", "three") assert done, "Should be done" end def check_tasks(n1, n2, n3) t = Task[n1] assert Task === t, "Should be a Task" assert_equal n1.to_s, t.name assert_equal [n2.to_s], t.prerequisites.collect{|n| n.to_s} t.invoke t2 = Task[n2] assert_equal FileList[], t2.prerequisites t3 = Task[n3] assert_equal [n1.to_s, n2.to_s], t3.prerequisites.collect{|n|n.to_s} end def test_incremental_definitions runs = [] task :t1 => [:t2] do runs << "A"; 4321 end task :t1 => [:t3] do runs << "B"; 1234 end task :t1 => [:t3] task :t2 task :t3 Task[:t1].invoke assert_equal ["A", "B"], runs assert_equal ["t2", "t3"], Task[:t1].prerequisites end def test_missing_dependencies task :x => ["missing"] assert_raises(RuntimeError) { Task[:x].invoke } end def test_implicit_file_dependencies runs = [] create_existing_file task :y => [EXISTINGFILE] do |t| runs << t.name end Task[:y].invoke assert_equal runs, ['y'] end private # ---------------------------------------------------------- def create_existing_file Dir.mkdir File.dirname(EXISTINGFILE) unless File.exist?(File.dirname(EXISTINGFILE)) open(EXISTINGFILE, "w") do |f| f.puts "HI" end unless File.exist?(EXISTINGFILE) end end rake-10.0.4/test/test_rake_pseudo_status.rb0000644000004100000410000000077212124115317021020 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakePseudoStatus < Rake::TestCase def test_with_zero_exit_status s = Rake::PseudoStatus.new assert_equal 0, s.exitstatus assert_equal 0, s.to_i assert_equal 0, s >> 8 refute s.stopped? assert s.exited? end def test_with_99_exit_status s = Rake::PseudoStatus.new(99) assert_equal 99, s.exitstatus assert_equal 25344, s.to_i assert_equal 99, s >> 8 refute s.stopped? assert s.exited? end end rake-10.0.4/test/test_rake_file_creation_task.rb0000644000004100000410000000333412124115317021740 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'fileutils' ###################################################################### class TestRakeFileCreationTask < Rake::TestCase include Rake include Rake::DSL DUMMY_DIR = 'dummy_dir' def setup super Task.clear end def test_file_needed create_dir DUMMY_DIR fc_task = Task[DUMMY_DIR] assert_equal DUMMY_DIR, fc_task.name FileUtils.rm_rf fc_task.name assert fc_task.needed?, "file should be needed" FileUtils.mkdir fc_task.name assert_equal nil, fc_task.prerequisites.collect{|n| Task[n].timestamp}.max assert ! fc_task.needed?, "file should not be needed" end def test_directory directory DUMMY_DIR fc_task = Task[DUMMY_DIR] assert_equal DUMMY_DIR, fc_task.name assert FileCreationTask === fc_task end def test_no_retriggers_on_filecreate_task create_timed_files(OLDFILE, NEWFILE) t1 = Rake.application.intern(FileCreationTask, OLDFILE).enhance([NEWFILE]) t2 = Rake.application.intern(FileCreationTask, NEWFILE) assert ! t2.needed?, "Should not need to build new file" assert ! t1.needed?, "Should not need to rebuild old file because of new" end def test_no_retriggers_on_file_task create_timed_files(OLDFILE, NEWFILE) t1 = Rake.application.intern(FileCreationTask, OLDFILE).enhance([NEWFILE]) t2 = Rake.application.intern(FileCreationTask, NEWFILE) assert ! t2.needed?, "Should not need to build new file" assert ! t1.needed?, "Should not need to rebuild old file because of new" end def test_very_early_timestamp t1 = Rake.application.intern(FileCreationTask, OLDFILE) assert t1.timestamp < Time.now assert t1.timestamp < Time.now - 1000000 end end rake-10.0.4/test/test_rake_win32.rb0000644000004100000410000000345512124115317017061 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakeWin32 < Rake::TestCase Win32 = Rake::Win32 def test_win32_system_dir_uses_home_if_defined ENV['HOME'] = 'C:\\HP' assert_equal "C:/HP/Rake", Win32.win32_system_dir end def test_win32_system_dir_uses_homedrive_homepath_when_no_home_defined ENV['HOME'] = nil ENV['HOMEDRIVE'] = 'C:' ENV['HOMEPATH'] = '\\HP' assert_equal "C:/HP/Rake", Win32.win32_system_dir end def test_win32_system_dir_uses_appdata_when_no_home_or_home_combo ENV['APPDATA'] = "C:\\Documents and Settings\\HP\\Application Data" ENV['HOME'] = nil ENV['HOMEDRIVE'] = nil ENV['HOMEPATH'] = nil assert_equal "C:/Documents and Settings/HP/Application Data/Rake", Win32.win32_system_dir end def test_win32_system_dir_fallback_to_userprofile_otherwise ENV['HOME'] = nil ENV['HOMEDRIVE'] = nil ENV['HOMEPATH'] = nil ENV['APPDATA'] = nil ENV['USERPROFILE'] = "C:\\Documents and Settings\\HP" assert_equal "C:/Documents and Settings/HP/Rake", Win32.win32_system_dir end def test_win32_system_dir_nil_of_no_env_vars ENV['APPDATA'] = nil ENV['HOME'] = nil ENV['HOMEDRIVE'] = nil ENV['HOMEPATH'] = nil ENV['RAKE_SYSTEM'] = nil ENV['USERPROFILE'] = nil assert_raises(Rake::Win32::Win32HomeError) do Win32.win32_system_dir end end def test_win32_backtrace_with_different_case ex = nil begin raise 'test exception' rescue => ex end ex.set_backtrace ['abc', 'rakefile'] rake = Rake::Application.new rake.options.trace = true rake.instance_variable_set(:@rakefile, 'Rakefile') _, err = capture_io { rake.display_error_message(ex) } assert_match(/rakefile/, err) end end rake-10.0.4/test/test_rake_top_level_functions.rb0000644000004100000410000000237312124115317022176 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakeTopLevelFunctions < Rake::TestCase def setup super @app = Object.new def @app.called @called end def @app.method_missing(*a, &b) @called ||= [] @called << [a, b] nil end Rake.application = @app end def test_namespace block = proc do end namespace("xyz", &block) expected = [ [[:in_namespace, 'xyz'], block] ] assert_equal expected, @app.called end def test_import import('x', 'y', 'z') expected = [ [[:add_import, 'x'], nil], [[:add_import, 'y'], nil], [[:add_import, 'z'], nil], ] assert_equal expected, @app.called end def test_when_writing out, = capture_io do when_writing("NOTWRITING") do puts "WRITING" end end assert_equal "WRITING\n", out end def test_when_not_writing Rake::FileUtilsExt.nowrite_flag = true _, err = capture_io do when_writing("NOTWRITING") do puts "WRITING" end end assert_equal "DRYRUN: NOTWRITING\n", err ensure Rake::FileUtilsExt.nowrite_flag = false end def test_missing_other_constant assert_raises(NameError) do Object.const_missing(:Xyz) end end end rake-10.0.4/test/test_rake_file_task.rb0000644000004100000410000000601712124115317020055 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'fileutils' class TestRakeFileTask < Rake::TestCase include Rake def setup super Task.clear @runs = Array.new FileUtils.rm_f NEWFILE FileUtils.rm_f OLDFILE end def test_file_need name = "dummy" file name ftask = Task[name] assert_equal name.to_s, ftask.name File.delete(ftask.name) rescue nil assert ftask.needed?, "file should be needed" open(ftask.name, "w") { |f| f.puts "HI" } assert_equal nil, ftask.prerequisites.collect{|n| Task[n].timestamp}.max assert ! ftask.needed?, "file should not be needed" ensure File.delete(ftask.name) rescue nil end def test_file_times_new_depends_on_old create_timed_files(OLDFILE, NEWFILE) t1 = Rake.application.intern(FileTask, NEWFILE).enhance([OLDFILE]) t2 = Rake.application.intern(FileTask, OLDFILE) assert ! t2.needed?, "Should not need to build old file" assert ! t1.needed?, "Should not need to rebuild new file because of old" end def test_file_times_new_depend_on_regular_task_timestamps load_phony name = "dummy" task name create_timed_files(NEWFILE) t1 = Rake.application.intern(FileTask, NEWFILE).enhance([name]) assert t1.needed?, "depending on non-file task uses Time.now" task(name => :phony) assert t1.needed?, "unless the non-file task has a timestamp" end def test_file_times_old_depends_on_new create_timed_files(OLDFILE, NEWFILE) t1 = Rake.application.intern(FileTask,OLDFILE).enhance([NEWFILE]) t2 = Rake.application.intern(FileTask, NEWFILE) assert ! t2.needed?, "Should not need to build new file" preq_stamp = t1.prerequisites.collect{|t| Task[t].timestamp}.max assert_equal t2.timestamp, preq_stamp assert t1.timestamp < preq_stamp, "T1 should be older" assert t1.needed?, "Should need to rebuild old file because of new" end def test_file_depends_on_task_depend_on_file create_timed_files(OLDFILE, NEWFILE) file NEWFILE => [:obj] do |t| @runs << t.name end task :obj => [OLDFILE] do |t| @runs << t.name end file OLDFILE do |t| @runs << t.name end Task[:obj].invoke Task[NEWFILE].invoke assert @runs.include?(NEWFILE) end def test_existing_file_depends_on_non_existing_file @ran = false create_file(OLDFILE) delete_file(NEWFILE) file NEWFILE do @ran = true end file OLDFILE => NEWFILE Task[OLDFILE].invoke assert @ran end # I have currently disabled this test. I'm not convinced that # deleting the file target on failure is always the proper thing to # do. I'm willing to hear input on this topic. def ztest_file_deletes_on_failure task :obj file NEWFILE => [:obj] do |t| FileUtils.touch NEWFILE fail "Ooops" end assert Task[NEWFILE] begin Task[NEWFILE].invoke rescue Exception end assert( ! File.exist?(NEWFILE), "NEWFILE should be deleted") end def load_phony load File.join(@rake_lib, "rake/phony.rb") end end rake-10.0.4/test/test_rake_dsl.rb0000644000004100000410000000137112124115317016674 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakeDsl < Rake::TestCase def setup super Rake::Task.clear end def test_namespace_command namespace "n" do task "t" end refute_nil Rake::Task["n:t"] end def test_namespace_command_with_bad_name ex = assert_raises(ArgumentError) do namespace 1 do end end assert_match(/string/i, ex.message) assert_match(/symbol/i, ex.message) end def test_namespace_command_with_a_string_like_object name = Object.new def name.to_str "bob" end namespace name do task "t" end refute_nil Rake::Task["bob:t"] end def test_no_commands_constant assert ! defined?(Commands), "should not define Commands" end end rake-10.0.4/test/test_rake_thread_pool.rb0000644000004100000410000000574712124115317020425 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'rake/thread_pool' require 'test/unit/assertions' class TestRakeTestThreadPool < Rake::TestCase include Rake def test_pool_executes_in_current_thread_for_zero_threads pool = ThreadPool.new(0) f = pool.future{Thread.current} pool.join assert_equal Thread.current, f.value end def test_pool_executes_in_other_thread_for_pool_of_size_one pool = ThreadPool.new(1) f = pool.future{Thread.current} pool.join refute_equal Thread.current, f.value end def test_pool_executes_in_two_other_threads_for_pool_of_size_two pool = ThreadPool.new(2) threads = 2.times.collect{ pool.future{ sleep 0.1; Thread.current } }.each{|f|f.value} refute_equal threads[0], threads[1] refute_equal Thread.current, threads[0] refute_equal Thread.current, threads[1] end def test_pool_creates_the_correct_number_of_threads pool = ThreadPool.new(2) threads = Set.new t_mutex = Mutex.new 10.times.each do pool.future do sleep 0.02 t_mutex.synchronize{ threads << Thread.current } end end pool.join assert_equal 2, threads.count end def test_pool_future_does_NOT_duplicate_arguments pool = ThreadPool.new(2) obj = Object.new captured = nil pool.future(obj) { |var| captured = var } pool.join assert_equal obj, captured end def test_pool_join_empties_queue pool = ThreadPool.new(2) repeat = 25 repeat.times { pool.future do repeat.times { pool.future do repeat.times { pool.future do end } end } end } pool.join assert_equal true, pool.__send__(:__queue__).empty?, "queue should be empty" end CustomError = Class.new(StandardError) # test that throwing an exception way down in the blocks propagates # to the top def test_exceptions pool = ThreadPool.new(10) deep_exception_block = lambda do |count| raise CustomError if ( count < 1 ) pool.future(count-1, &deep_exception_block).value end assert_raises(CustomError) do pool.future(2, &deep_exception_block).value end end def test_pool_prevents_deadlock pool = ThreadPool.new(5) common_dependency_a = pool.future { sleep 0.2 } futures_a = 10.times.collect { pool.future{ common_dependency_a.value; sleep(rand() * 0.01) } } common_dependency_b = pool.future { futures_a.each { |f| f.value } } futures_b = 10.times.collect { pool.future{ common_dependency_b.value; sleep(rand() * 0.01) } } futures_b.each{|f|f.value} pool.join end def test_pool_reports_correct_results pool = ThreadPool.new(7) a = 18 b = 5 c = 3 result = a.times.collect do pool.future do b.times.collect do pool.future { sleep rand * 0.001; c } end.inject(0) { |m,f| m+f.value } end end.inject(0) { |m,f| m+f.value } assert_equal( (a*b*c), result ) pool.join end end rake-10.0.4/test/test_rake_file_list_path_map.rb0000644000004100000410000000033512124115317021734 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakeFileListPathMap < Rake::TestCase def test_file_list_supports_pathmap assert_equal ['a', 'b'], FileList['dir/a.rb', 'dir/b.rb'].pathmap("%n") end end rake-10.0.4/test/test_rake_path_map_partial.rb0000644000004100000410000000074112124115317021417 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakePathMapPartial < Rake::TestCase def test_pathmap_partial @path = "1/2/file" def @path.call(n) pathmap_partial(n) end assert_equal("1", @path.call(1)) assert_equal("1/2", @path.call(2)) assert_equal("1/2", @path.call(3)) assert_equal(".", @path.call(0)) assert_equal("2", @path.call(-1)) assert_equal("1/2", @path.call(-2)) assert_equal("1/2", @path.call(-3)) end end rake-10.0.4/test/test_rake_require.rb0000644000004100000410000000156312124115317017571 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakeRequire < Rake::TestCase def test_can_load_rake_library rakefile_rakelib app = Rake::Application.new assert app.instance_eval { rake_require("test2", ['rakelib'], []) } end def test_wont_reload_rake_library rakefile_rakelib app = Rake::Application.new paths = ['rakelib'] loaded_files = [] app.rake_require("test2", paths, loaded_files) assert ! app.instance_eval { rake_require("test2", paths, loaded_files) } end def test_throws_error_if_library_not_found rakefile_rakelib app = Rake::Application.new ex = assert_raises(LoadError) { assert app.instance_eval { rake_require("testx", ['rakelib'], []) } } assert_match(/(can *not|can't)\s+find/i, ex.message) assert_match(/testx/, ex.message) end end rake-10.0.4/test/test_rake_task.rb0000644000004100000410000002006612124115317017056 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'fileutils' class TestRakeTask < Rake::TestCase include Rake def setup super Task.clear Rake::TaskManager.record_task_metadata = true end def teardown Rake::TaskManager.record_task_metadata = false super 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 assert_equal 1, t.locations.size assert_match(/#{Regexp.quote(__FILE__)}/, t.locations.first) end def test_inspect t = task(:foo => [:bar, :baz]) assert_equal " [bar, baz]>", t.inspect end def test_invoke runlist = [] t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 } task(:t2) { |t| runlist << t.name } 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_raises 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 } _, err = capture_io { t1.invoke } assert_match(/execute .*t1/i, err) assert_match(/dry run/i, err) refute_match(/invoke/i, err) assert_equal [], runlist ensure Rake.application.options.dryrun = false end def test_tasks_can_be_traced Rake.application.options.trace = true t1 = task(:t1) _, err = capture_io { t1.invoke } assert_match(/invoke t1/i, err) assert_match(/execute t1/i, err) ensure Rake.application.options.trace = false end def test_no_double_invoke runlist = [] t1 = task(:t1 => [:t2, :t3]) { |t| runlist << t.name; 3321 } task(:t2 => [:t3]) { |t| runlist << t.name } 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 desc "a task" t = task("t" => "a") { } t.clear assert t.prerequisites.empty?, "prerequisites should be empty" assert t.actions.empty?, "actions should be empty" assert_nil t.comment, "comments 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_clear_comments desc "the original foo" task :foo => [:x] do # Dummy action end task(:foo).clear_comments desc "a slightly different foo" task :foo assert_equal "a slightly different foo", task(:foo).comment assert_equal ["x"], task(:foo).prerequisites assert_equal 1, task(:foo).actions.size end def test_find task :tfind assert_equal "tfind", Task[:tfind].name ex = assert_raises(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_prerequiste_tasks_returns_tasks_not_strings a = task :a => ["b", "c"] b = task :b c = task :c assert_equal [b, c], a.prerequisite_tasks end def test_prerequiste_tasks_fails_if_prerequisites_are_undefined a = task :a => ["b", "c"] task :b assert_raises(RuntimeError) do a.prerequisite_tasks end end def test_prerequiste_tasks_honors_namespaces a = b = nil namespace "X" do a = task :a => ["b", "c"] b = task :b end c = task :c assert_equal [b, c], a.prerequisite_tasks end def test_all_prerequisite_tasks_includes_all_prerequisites a = task :a => "b" b = task :b => ["c", "d"] c = task :c => "e" d = task :d e = task :e assert_equal [b, c, d, e], a.all_prerequisite_tasks.sort_by { |t| t.name } end def test_all_prerequisite_tasks_does_not_include_duplicates a = task :a => ["b", "c"] b = task :b => "c" c = task :c assert_equal [b, c], a.all_prerequisite_tasks.sort_by { |t| t.name } end def test_all_prerequisite_tasks_includes_self_on_cyclic_dependencies a = task :a => "b" b = task :b => "a" assert_equal [a, b], a.all_prerequisite_tasks.sort_by { |t| t.name } end def test_timestamp_returns_now_if_all_prereqs_have_no_times a = task :a => ["b", "c"] task :b task :c assert_in_delta Time.now, a.timestamp, 0.1, 'computer too slow?' end def test_timestamp_returns_latest_prereq_timestamp a = task :a => ["b", "c"] b = task :b c = task :c now = Time.now def b.timestamp() Time.now + 10 end def c.timestamp() Time.now + 5 end assert_in_delta now, a.timestamp, 0.1, 'computer too slow?' end def test_always_multitask mx = Mutex.new result = [] t_a = task(:a) do |t| sleep 0.02 mx.synchronize{ result << t.name } end t_b = task(:b) do |t| mx.synchronize{ result << t.name } end t_c = task(:c => [:a,:b]) do |t| mx.synchronize{ result << t.name } end t_c.invoke # task should always run in order assert_equal ['a', 'b', 'c'], result [t_a, t_b, t_c].each { |t| t.reenable } result.clear Rake.application.options.always_multitask = true t_c.invoke # with multitask, task 'b' should grab the mutex first assert_equal ['b', 'a', 'c'], result 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 rake-10.0.4/test/test_rake_ftp_file.rb0000644000004100000410000000322712124115317017704 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'date' require 'time' require 'rake/contrib/ftptools' class FakeDate def self.today Date.new(2003,10,3) end def self.now Time.local(2003,10,3,12,00,00) end end class TestRakeFtpFile < Rake::TestCase def setup super Rake::FtpFile.class_eval { @date_class = FakeDate; @time_class = FakeDate } end def test_general file = Rake::FtpFile.new("here", "-rw-r--r-- 1 a279376 develop 121770 Mar 6 14:50 wiki.pl") assert_equal "wiki.pl", file.name assert_equal "here/wiki.pl", file.path assert_equal "a279376", file.owner assert_equal "develop", file.group assert_equal 0644, file.mode assert_equal 121770, file.size assert_equal Time.mktime(2003,3,6,14,50,0,0), file.time assert ! file.directory? assert ! file.symlink? end def test_far_date file = Rake::FtpFile.new(".", "drwxr-xr-x 3 a279376 develop 4096 Nov 26 2001 vss") assert_equal Time.mktime(2001,11,26,0,0,0,0), file.time end def test_close_date file = Rake::FtpFile.new(".", "drwxr-xr-x 3 a279376 develop 4096 Nov 26 15:35 vss") assert_equal Time.mktime(2002,11,26,15,35,0,0), file.time end def test_directory file = Rake::FtpFile.new(".", "drwxrwxr-x 9 a279376 develop 4096 Mar 13 14:32 working") assert file.directory? assert !file.symlink? end def test_symlink file = Rake::FtpFile.new(".", "lrwxrwxrwx 1 a279376 develop 64 Mar 26 2002 xtrac -> /home/a279376/working/ics/development/java/com/fmr/fwp/ics/xtrac") assert_equal 'xtrac', file.name assert file.symlink? assert !file.directory? end end rake-10.0.4/test/test_rake_file_utils.rb0000644000004100000410000001427612124115317020261 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'fileutils' require 'stringio' class TestRakeFileUtils < Rake::TestCase def teardown FileUtils::LN_SUPPORTED[0] = true RakeFileUtils.verbose_flag = Rake::FileUtilsExt::DEFAULT super end def test_rm_one_file create_file("a") FileUtils.rm_rf "a" refute File.exist?("a") end def test_rm_two_files create_file("a") create_file("b") FileUtils.rm_rf ["a", "b"] refute File.exist?("a") refute File.exist?("b") end def test_rm_filelist list = Rake::FileList.new << "a" << "b" list.each { |fn| create_file(fn) } FileUtils.rm_r list refute File.exist?("a") refute File.exist?("b") end def test_ln open("a", "w") { |f| f.puts "TEST_LN" } Rake::FileUtilsExt.safe_ln("a", "b", :verbose => false) assert_equal "TEST_LN\n", File.read('b') end class BadLink include Rake::FileUtilsExt attr_reader :cp_args def initialize(klass) @failure_class = klass end def cp(*args) @cp_args = args end def ln(*args) fail @failure_class, "ln not supported" end public :safe_ln end def test_safe_ln_failover_to_cp_on_standard_error FileUtils::LN_SUPPORTED[0] = true c = BadLink.new(StandardError) c.safe_ln "a", "b" assert_equal ['a', 'b'], c.cp_args c.safe_ln "x", "y" assert_equal ['x', 'y'], c.cp_args end def test_safe_ln_failover_to_cp_on_not_implemented_error FileUtils::LN_SUPPORTED[0] = true c = BadLink.new(NotImplementedError) c.safe_ln "a", "b" assert_equal ['a', 'b'], c.cp_args end def test_safe_ln_fails_on_script_error FileUtils::LN_SUPPORTED[0] = true c = BadLink.new(ScriptError) assert_raises(ScriptError) do c.safe_ln "a", "b" end end def test_verbose verbose true assert_equal true, verbose verbose false assert_equal false, verbose verbose(true) { assert_equal true, verbose } assert_equal false, verbose end def test_nowrite nowrite true assert_equal true, nowrite nowrite false assert_equal false, nowrite nowrite(true){ assert_equal true, nowrite } assert_equal false, nowrite end def test_file_utils_methods_are_available_at_top_level create_file("a") capture_io do rm_rf "a" end refute File.exist?("a") end def test_fileutils_methods_dont_leak obj = Object.new assert_raises(NoMethodError) { obj.copy } # from FileUtils assert_raises(NoMethodError) { obj.ruby "-v" } # from RubyFileUtils end def test_sh shellcommand verbose(false) { sh %{#{Rake::TestCase::RUBY} shellcommand.rb} } assert true, "should not fail" end def test_sh_with_a_single_string_argument check_expansion ENV['RAKE_TEST_SH'] = 'someval' verbose(false) { sh %{#{RUBY} check_expansion.rb #{env_var} someval} } end def test_sh_with_multiple_arguments check_no_expansion ENV['RAKE_TEST_SH'] = 'someval' verbose(false) { sh RUBY, 'check_no_expansion.rb', env_var, 'someval' } end def test_sh_failure shellcommand assert_raises(RuntimeError) { verbose(false) { sh %{#{RUBY} shellcommand.rb 1} } } end def test_sh_special_handling shellcommand count = 0 verbose(false) { sh(%{#{RUBY} shellcommand.rb}) do |ok, res| assert(ok) assert_equal 0, res.exitstatus count += 1 end sh(%{#{RUBY} shellcommand.rb 1}) do |ok, res| assert(!ok) assert_equal 1, res.exitstatus count += 1 end } assert_equal 2, count, "Block count should be 2" end def test_sh_noop shellcommand verbose(false) { sh %{shellcommand.rb 1}, :noop=>true } assert true, "should not fail" end def test_sh_bad_option shellcommand ex = assert_raises(ArgumentError) { verbose(false) { sh %{shellcommand.rb}, :bad_option=>true } } assert_match(/bad_option/, ex.message) end def test_sh_verbose shellcommand _, err = capture_io do verbose(true) { sh %{shellcommand.rb}, :noop=>true } end assert_equal "shellcommand.rb\n", err end def test_sh_verbose_false shellcommand _, err = capture_io do verbose(false) { sh %{shellcommand.rb}, :noop=>true } end assert_equal '', err end def test_sh_verbose_flag_nil shellcommand RakeFileUtils.verbose_flag = nil assert_silent do sh %{shellcommand.rb}, :noop=>true end end def test_ruby_with_a_single_string_argument check_expansion ENV['RAKE_TEST_SH'] = 'someval' verbose(false) { replace_ruby { ruby %{check_expansion.rb #{env_var} someval} } } end def test_ruby_with_multiple_arguments check_no_expansion ENV['RAKE_TEST_SH'] = 'someval' verbose(false) { replace_ruby { ruby 'check_no_expansion.rb', env_var, 'someval' } } end def test_split_all assert_equal ['a'], Rake::FileUtilsExt.split_all('a') assert_equal ['..'], Rake::FileUtilsExt.split_all('..') assert_equal ['/'], Rake::FileUtilsExt.split_all('/') assert_equal ['a', 'b'], Rake::FileUtilsExt.split_all('a/b') assert_equal ['/', 'a', 'b'], Rake::FileUtilsExt.split_all('/a/b') assert_equal ['..', 'a', 'b'], Rake::FileUtilsExt.split_all('../a/b') end def command name, text open name, 'w', 0750 do |io| io << text end end def check_no_expansion command 'check_no_expansion.rb', <<-CHECK_EXPANSION if ARGV[0] != ARGV[1] exit 0 else exit 1 end CHECK_EXPANSION end def check_expansion command 'check_expansion.rb', <<-CHECK_EXPANSION if ARGV[0] != ARGV[1] exit 1 else exit 0 end CHECK_EXPANSION end def replace_ruby ruby = FileUtils::RUBY FileUtils.send :remove_const, :RUBY FileUtils.const_set :RUBY, RUBY yield ensure FileUtils.send :remove_const, :RUBY FileUtils.const_set:RUBY, ruby end def shellcommand command 'shellcommand.rb', <<-SHELLCOMMAND #!/usr/bin/env ruby exit((ARGV[0] || "0").to_i) SHELLCOMMAND end def env_var windows? ? '%RAKE_TEST_SH%' : '$RAKE_TEST_SH' end def windows? ! File::ALT_SEPARATOR.nil? end end rake-10.0.4/test/test_rake_invocation_chain.rb0000644000004100000410000000206012124115317021421 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) class TestRakeInvocationChain < Rake::TestCase def setup super @empty = Rake::InvocationChain::EMPTY @first_member = "A" @second_member = "B" @one = @empty.append(@first_member) @two = @one.append(@second_member) end def test_append chain = @empty.append("A") assert_equal 'TOP => A', chain.to_s # HACK end def test_append_one_circular ex = assert_raises RuntimeError do @one.append(@first_member) end assert_match(/circular +dependency/i, ex.message) assert_match(/A.*=>.*A/, ex.message) end def test_append_two_circular ex = assert_raises RuntimeError do @two.append(@first_member) end assert_match(/A.*=>.*B.*=>.*A/, ex.message) end def test_member_eh_one assert @one.member?(@first_member) end def test_member_eh_two assert @two.member?(@first_member) assert @two.member?(@second_member) end def test_to_s_empty assert_equal "TOP", @empty.to_s assert_equal "TOP => A", @one.to_s end end rake-10.0.4/test/test_rake_test_task.rb0000644000004100000410000000523612124115317020117 0ustar www-datawww-datarequire File.expand_path('../helper', __FILE__) require 'rake/testtask' class TestRakeTestTask < Rake::TestCase include Rake def test_initialize tt = Rake::TestTask.new do |t| end refute_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_initialize_override tt = Rake::TestTask.new(:example) do |t| t.libs = ['src', 'ext'] t.pattern = 'test/tc_*.rb' t.verbose = true end refute_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_file_list_ENV_TEST ENV['TEST'] = 'testfile.rb' tt = Rake::TestTask.new do |t| t.pattern = '*' end assert_equal ["testfile.rb"], tt.file_list.to_a ensure ENV.delete 'TEST' end def test_libs_equals test_task = Rake::TestTask.new do |t| t.libs << ["A", "B"] end path = %w[lib A B].join File::PATH_SEPARATOR assert_equal "-I\"#{path}\"", test_task.ruby_opts_string end def test_libs_equals_empty test_task = Rake::TestTask.new do |t| t.libs = [] end assert_equal '', test_task.ruby_opts_string end def test_pattern_equals tt = Rake::TestTask.new do |t| t.pattern = '*.rb' end assert_equal ['*.rb'], tt.file_list.to_a end def test_pattern_equals_test_files_equals tt = Rake::TestTask.new do |t| t.test_files = FileList['a.rb', 'b.rb'] t.pattern = '*.rb' end assert_equal ['a.rb', 'b.rb', '*.rb'], tt.file_list.to_a end def test_run_code_direct test_task = Rake::TestTask.new do |t| t.loader = :direct end assert_equal '-e "ARGV.each{|f| require f}"', test_task.run_code end def test_run_code_rake test_task = Rake::TestTask.new do |t| t.loader = :rake end assert_match(/-I".*?" ".*?"/, test_task.run_code) end def test_run_code_testrb_ruby_1_8_2 test_task = Rake::TestTask.new do |t| t.loader = :testrb end def test_task.ruby_version() '1.8.2' end assert_match(/^-S testrb +".*"$/, test_task.run_code) end def test_run_code_testrb_ruby_1_8_6 test_task = Rake::TestTask.new do |t| t.loader = :testrb end def test_task.ruby_version() '1.8.6' end assert_match(/^-S testrb +$/, test_task.run_code) end def test_test_files_equals 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 end rake-10.0.4/doc/0000755000004100000410000000000012124115317013310 5ustar www-datawww-datarake-10.0.4/doc/rational.rdoc0000644000004100000410000001411012124115317015767 0ustar www-datawww-data= Why rake? Ok, let me state from the beginning that I never intended to write this code. I'm not convinced it is useful, and I'm not convinced anyone would even be interested in it. All I can say is that Why's onion truck must by been passing through the Ohio valley. What am I talking about? ... A Ruby version of Make. See, I can sense you cringing already, and I agree. The world certainly doesn't need yet another reworking of the "make" program. I mean, we already have "ant". Isn't that enough? It started yesterday. I was helping a coworker fix a problem in one of the Makefiles we use in our project. Not a particularly tough problem, but during the course of the conversation I began lamenting some of the shortcomings of make. In particular, in one of my makefiles I wanted to determine the name of a file dynamically and had to resort to some simple scripting (in Ruby) to make it work. "Wouldn't it be nice if you could just use Ruby inside a Makefile" I said. My coworker (a recent convert to Ruby) agreed, but wondered what it would look like. So I sketched the following on the whiteboard... "What if you could specify the make tasks in Ruby, like this ..." task "build" do java_compile(...args, etc ...) end "The task function would register "build" as a target to be made, and the block would be the action executed whenever the build system determined that it was time to do the build target." We agreed that would be cool, but writing make from scratch would be WAY too much work. And that was the end of that! ... Except I couldn't get the thought out of my head. What exactly would be needed to make the about syntax work as a make file? Hmmm, you would need to register the tasks, you need some way of specifying dependencies between tasks, and some way of kicking off the process. Hey! What if we did ... and fifteen minutes later I had a working prototype of Ruby make, complete with dependencies and actions. I showed the code to my coworker and we had a good laugh. It was just about a page worth of code that reproduced an amazing amount of the functionality of make. We were both truly stunned with the power of Ruby. But it didn't do everything make did. In particular, it didn't have timestamp based file dependencies (where a file is rebuilt if any of its prerequisite files have a later timestamp). Obviously THAT would be a pain to add and so Ruby Make would remain an interesting experiment. ... Except as I walked back to my desk, I started thinking about what file based dependencies would really need. Rats! I was hooked again, and by adding a new class and two new methods, file/timestamp dependencies were implemented. Ok, now I was really hooked. Last night (during CSI!) I massaged the code and cleaned it up a bit. The result is a bare-bones replacement for make in exactly 100 lines of code. For the curious, you can see it at ... * doc/proto_rake.rdoc Oh, about the name. When I wrote the example Ruby Make task on my whiteboard, my coworker exclaimed "Oh! I have the perfect name: Rake ... Get it? Ruby-Make. Rake!" He said he envisioned the tasks as leaves and Rake would clean them up ... or something like that. Anyways, the name stuck. Some quick examples ... A simple task to delete backup files ... task :clean do Dir['*~'].each {|fn| rm fn rescue nil} end Note that task names are symbols (they are slightly easier to type than quoted strings ... but you may use quoted string if you would rather). Rake makes the methods of the FileUtils module directly available, so we take advantage of the rm command. Also note the use of "rescue nil" to trap and ignore errors in the rm command. To run it, just type "rake clean". Rake will automatically find a Rakefile in the current directory (or above!) and will invoke the targets named on the command line. If there are no targets explicitly named, rake will invoke the task "default". Here's another task with dependencies ... task :clobber => [:clean] do rm_r "tempdir" end Task :clobber depends upon task :clean, so :clean will be run before :clobber is executed. Files are specified by using the "file" command. It is similar to the task command, except that the task name represents a file, and the task will be run only if the file doesn't exist, or if its modification time is earlier than any of its prerequisites. Here is a file based dependency that will compile "hello.cc" to "hello.o". file "hello.cc" file "hello.o" => ["hello.cc"] do |t| srcfile = t.name.sub(/\.o$/, ".cc") sh %{g++ #{srcfile} -c -o #{t.name}} end I normally specify file tasks with string (rather than symbols). Some file names can't be represented by symbols. Plus it makes the distinction between them more clear to the casual reader. Currently writing a task for each and every file in the project would be tedious at best. I envision a set of libraries to make this job easier. For instance, perhaps something like this ... require 'rake/ctools' Dir['*.c'].each do |fn| c_source_file(fn) end where "c_source_file" will create all the tasks need to compile all the C source files in a directory. Any number of useful libraries could be created for rake. That's it. There's no documentation (other than whats in this message). Does this sound interesting to anyone? If so, I'll continue to clean it up and write it up and publish it on RAA. Otherwise, I'll leave it as an interesting exercise and a tribute to the power of Ruby. Why /might/ rake be interesting to Ruby programmers. I don't know, perhaps ... * No weird make syntax (only weird Ruby syntax :-) * No need to edit or read XML (a la ant) * Platform independent build scripts. * Will run anywhere Ruby exists, so no need to have "make" installed. If you stay away from the "sys" command and use things like 'ftools', you can have a perfectly platform independent build script. Also rake is only 100 lines of code, so it can easily be packaged along with the rest of your code. So ... Sorry for the long rambling message. Like I said, I never intended to write this code at all. rake-10.0.4/doc/glossary.rdoc0000644000004100000410000000346312124115317016032 0ustar www-datawww-data= Glossary [action] Code to be executed in order to perform a task. Actions in a rakefile are specified in a code block (usually delimited by +do+/+end+ pairs. [execute] When a task is executed, all of its actions are performed, in the order they were defined. Note that unlike invoke, execute always executes the actions (without invoking or executing the prerequisites). [file task (FileTask)] A file task is a task whose purpose is to create a file (which has the same name as the task). When invoked, a file task will only execute if one or more of the following conditions are true. 1. The associated file does not exist. 2. A prerequisite has a later time stamp than the existing file. Because normal Tasks always have the current time as timestamp, a FileTask that has a normal Task prerequisite will always execute. [invoke] When a task is invoked, first we check to see if it has been invoked before. if it has been, then nothing else is done. If this is the first time its been invoked, then we invoke each of its prerequisites. Finally, we check to see if we need to execute the actions of this task by calling needed?. Finally, if the task is needed, we execute its actions. NOTE: Currently prerequisites are invoked even if the task is not needed. This may change in the future. [prerequisites] Every task has a set (possibly empty) of prerequisites. A prerequisite P to Task T is itself a task that must be invoked before Task T. [rule] A rule is a recipe for synthesizing a task when no task is explicitly defined. Rules generally synthesize file tasks. [task (Task)] Basic unit of work in a rakefile. A task has a name, a set of prerequisites and a list of actions to be performed. rake-10.0.4/doc/example/0000755000004100000410000000000012124115317014743 5ustar www-datawww-datarake-10.0.4/doc/example/b.c0000644000004100000410000000010112124115317015320 0ustar www-datawww-data#include void b() { printf ("In function b\n"); } rake-10.0.4/doc/example/Rakefile10000644000004100000410000000123612124115317016473 0ustar www-datawww-data# Example Rakefile -*- ruby -*- task :default => [:main] file "a.o" => ["a.c"] do |t| src = t.name.sub(/\.o$/, '.c') sh "gcc #{src} -c -o #{t.name}" end file "b.o" => ["b.c"] do |t| src = t.name.sub(/\.o$/, '.c') sh "gcc #{src} -c -o #{t.name}" end file "main.o" => ["main.c"] do |t| src = t.name.sub(/\.o$/, '.c') sh "gcc #{src} -c -o #{t.name}" end OBJFILES = ["a.o", "b.o", "main.o"] task :obj => OBJFILES file "main" => OBJFILES do |t| sh "gcc -o #{t.name} main.o a.o b.o" end task :clean do rm_f FileList['*.o'] Dir['*~'].each { |fn| rm_f fn } end task :clobber => [:clean] do rm_f "main" end task :run => ["main"] do sh "./main" end rake-10.0.4/doc/example/Rakefile20000644000004100000410000000112712124115317016473 0ustar www-datawww-data# Example Rakefile -*- ruby -*- # Using the power of Ruby task :default => [:main] def ext(fn, newext) fn.sub(/\.[^.]+$/, newext) end SRCFILES = Dir['*.c'] OBJFILES = SRCFILES.collect { |fn| ext(fn,".o") } OBJFILES.each do |objfile| srcfile = ext(objfile, ".c") file objfile => [srcfile] do |t| sh "gcc #{srcfile} -c -o #{t.name}" end end file "main" => OBJFILES do |t| sh "gcc -o #{t.name} main.o a.o b.o" end task :clean do rm_f FileList['*.o'] Dir['*~'].each { |fn| rm_f fn } end task :clobber => [:clean] do rm_f "main" end task :run => ["main"] do sh "./main" end rake-10.0.4/doc/example/a.c0000644000004100000410000000010112124115317015317 0ustar www-datawww-data#include void a() { printf ("In function a\n"); } rake-10.0.4/doc/example/main.c0000644000004100000410000000014712124115317016035 0ustar www-datawww-data#include extern void a(); extern void b(); int main () { a(); b(); return 0; } rake-10.0.4/doc/rake.1.gz0000644000004100000410000000253212124115317014735 0ustar www-datawww-data‹àBrake.1VÛnÛF}çW ò©•è¸@‘ÂHÜ8±«õEä6A݇%947¦v™½Xa¿¾g—¤, y(j¶¼3{fæÌ™Y§w/è?}]p;¡ÙÕÙ‡Õ M˜’2º,ç$ÄGi¬£F±aÇfB×gW³ ÙJûº ŒIÔ5墱Ñ{ŹVžûjöa=¿¹Þ¿q<ýeBÑâãöˆ¬Ï,çNj´«Ø<X&ÆÐ[.NÈ2㦽Oâïãq’®/hyöûŒŽéÅGÎŒ¦¥ã×úéÕ«Ÿ_DÌEÍÂ¥øâQ‹«¤¥B8D¯Xñ#Â~”Vª{Ø"~#î9 W»¢ô†)’²¹ÑvB¥wJ6¬r>‰N©ªB iEV3UmƒbWZZµƒ Ž¿ë! ª;šKG!_Y¶;[ÖÙúcrš2ðÕù ðnä}她—Êöi•‡i•²®Qkg.åAJϬ™¬Àcã&¦Ì°xèlCoÔ鞃úñ˜xÓ¸6ºv9¶zR§¶á\–2ßQùÔÑ$]]Du%F<0ÝMÉÊMƒ”2/!œÆè{ˆ"ÊZ˜Pü~ñÖêóõÍb5_%é{2ñp9§¿H7YK'¨$:žÏV–óEPäàK•°±ï¥* *(Y8oØž$É´„HaK£àþÒcKº¤«Á8Ž:ÍuHØqÝRsÅxIˆ¬Cw„)hé³–l«œø–]kútuI:êáBºîø«—æ¡ÝÁˆx)xmµÂE¦½£‘ ¹ tŸœÈD ²Èù×qÈýÖ† Ê…¢ŽwHFØK[ Õ4úE +Ût(óØ4Ú8KƃûF8L¡ŠéÙ4YùSè‹Ì¥ëàžî"›:HpËá'J™»“õ9#3ïÀI ߺÑ_0ýs|‡2Á§BÆõÅ`5Ü0Dîp;WhRÚQ¬ì'@D"B‘‹ñàï0ìP‚u¼ §‹Eçš?‘4a#…kÝ5ªuq"b¶A wåû7[Ä+ãô®\„‘‹wåü¹-6"¨DbaCDö¤zÔÓÐr‰Å•ÈP惈É5a>B@iÔëM”*t½^$ÓiaÚ©ñjy¦jœœk´F ÆnãÜ» g·+ŠîP*®›ƒ'`4½Š´M â~ŒN¶¶Û„ñb-³Bš·—ó÷çóåpq>Næ*¯=Jë RE¶, “WA@U¿/c— \@Y»t”î=÷Ó¹ŽE…æî`°k! äN Nh4 èØéÚ>¯o±_÷c:Љ ]ä$ؘÃö`Ȳ9 ëë.»Zß,u#2 ::ÐøŠéS|ûq~9PÊq‚ù¤xÔ¯ sPJÏÙÛ«›óÛþâhjÆÉ²W|žqDûÔñC‹ÏÊTaÇɥĨôEN°g±Gj«ã €-wY½DGâÛ—`MiUo9èø<°þŸœ;ÆãÌ“µ7*Ìr˜¤>êÊ.ÜQôd÷‚yüG’‰ü!â  >ôè´zÊÐï+sœA–ÏÁ×S»¿Ómaé _»ñN|)žáüñœ–á]ë}Ãj /ÚlFg—«›ä³öq…â5)vï˰þršÿMŠé;òÖÙ ãrû‘žÈ³ÛõÅͲ{Z·ÛÖHlv¬æ–~“ú“¥‘˜³7_äæÝ¶ûkÄrªÍý)Åu¹‹oµu„ÈuÓNaÃJwë5,ôÒèÍNË)†XBIºÒaè-‚á¯wò15ú4Æù6óÊùáa QPe¿š‘N@âÓaÁò¿ßÈHôä rake-10.0.4/doc/proto_rake.rdoc0000644000004100000410000000470712124115317016336 0ustar www-datawww-data= Original Prototype Rake This is the original 100 line prototype rake program. --- #!/usr/bin/env ruby require 'ftools' class Task TASKS = Hash.new attr_reader :prerequisites def initialize(task_name) @name = task_name @prerequisites = [] @actions = [] end def enhance(deps=nil, &block) @prerequisites |= deps if deps @actions << block if block_given? self end def name @name.to_s end def invoke @prerequisites.each { |n| Task[n].invoke } execute if needed? end def execute return if @triggered @triggered = true @actions.collect { |act| result = act.call(self) }.last end def needed? true end def timestamp Time.now end class << self def [](task_name) TASKS[intern(task_name)] or fail "Don't know how to rake #{task_name}" end def define_task(args, &block) case args when Hash fail "Too Many Target Names: #{args.keys.join(' ')}" if args.size > 1 fail "No Task Name Given" if args.size < 1 task_name = args.keys[0] deps = args[task_name] else task_name = args deps = [] end deps = deps.collect {|d| intern(d) } get(task_name).enhance(deps, &block) end def get(task_name) name = intern(task_name) TASKS[name] ||= self.new(name) end def intern(task_name) (Symbol === task_name) ? task_name : task_name.intern end end end class FileTask < Task def needed? return true unless File.exist?(name) latest_prereq = @prerequisites.collect{|n| Task[n].timestamp}.max return false if latest_prereq.nil? timestamp < latest_prereq end def timestamp File.new(name.to_s).mtime end end def task(args, &block) Task.define_task(args, &block) end def file(args, &block) FileTask.define_task(args, &block) end def sys(cmd) puts cmd system(cmd) or fail "Command Failed: [#{cmd}]" end def rake begin here = Dir.pwd while ! File.exist?("Rakefile") Dir.chdir("..") fail "No Rakefile found" if Dir.pwd == here here = Dir.pwd end puts "(in #{Dir.pwd})" load "./Rakefile" ARGV.push("default") if ARGV.size == 0 ARGV.each { |task_name| Task[task_name].invoke } rescue Exception => ex puts "rake aborted ... #{ex.message}" puts ex.backtrace.find {|str| str =~ /Rakefile/ } || "" end end if __FILE__ == $0 then rake end rake-10.0.4/doc/jamis.rb0000644000004100000410000002612712124115317014750 0ustar www-datawww-datamodule RDoc module Page FONTS = "\"Bitstream Vera Sans\", Verdana, Arial, Helvetica, sans-serif" STYLE = < pre { padding: 0.5em; border: 1px dotted black; background: #FFE; } CSS XHTML_PREAMBLE = %{ } HEADER = XHTML_PREAMBLE + < %title% ENDHEADER FILE_PAGE = <
File
%short_name%
Path: %full_path% IF:cvsurl  (CVS) ENDIF:cvsurl
Modified: %dtm_modified%

HTML ################################################################### CLASS_PAGE = < %classmod%
%full_name% IF:parent ENDIF:parent
In: START:infiles HREF:full_path_url:full_path: IF:cvsurl  (CVS) ENDIF:cvsurl END:infiles
Parent: IF:par_url ENDIF:par_url %parent% IF:par_url ENDIF:par_url
HTML ################################################################### METHOD_LIST = < IF:diagram
%diagram%
ENDIF:diagram IF:description
%description%
ENDIF:description IF:requires
Required Files
    START:requires
  • HREF:aref:name:
  • END:requires
ENDIF:requires IF:toc
Contents
ENDIF:toc IF:methods
Methods
    START:methods
  • HREF:aref:name:
  • END:methods
ENDIF:methods IF:includes
Included Modules
    START:includes
  • HREF:aref:name:
  • END:includes
ENDIF:includes START:sections IF:sectitle IF:seccomment
%seccomment%
ENDIF:seccomment ENDIF:sectitle IF:classlist
Classes and Modules
%classlist% ENDIF:classlist IF:constants
Constants
START:constants IF:desc ENDIF:desc END:constants
%name% = %value%
  %desc%
ENDIF:constants IF:attributes
Attributes
START:attributes END:attributes
IF:rw [%rw%] ENDIF:rw %name% %a_desc%
ENDIF:attributes IF:method_list START:method_list IF:methods
%type% %category% methods
START:methods
IF:callseq %callseq% ENDIF:callseq IFNOT:callseq %name%%params% ENDIF:callseq IF:codeurl [ source ] ENDIF:codeurl
IF:m_desc
%m_desc%
ENDIF:m_desc IF:aka
This method is also aliased as START:aka %name% END:aka
ENDIF:aka IF:sourcecode
%sourcecode%
ENDIF:sourcecode
END:methods ENDIF:methods END:method_list ENDIF:method_list END:sections HTML FOOTER = < ENDFOOTER BODY = HEADER + <
#{METHOD_LIST}
#{FOOTER} ENDBODY ########################## Source code ########################## SRC_PAGE = XHTML_PREAMBLE + < %title%
%code%
HTML ########################## Index ################################ FR_INDEX_BODY = <
START:entries %name%
END:entries
HTML CLASS_INDEX = FILE_INDEX METHOD_INDEX = FILE_INDEX INDEX = XHTML_PREAMBLE + < %title% IF:inline_source ENDIF:inline_source IFNOT:inline_source ENDIF:inline_source <body bgcolor="white"> Click <a href="html/index.html">here</a> for a non-frames version of this page. </body> HTML end end rake-10.0.4/doc/rakefile.rdoc0000644000004100000410000004707612124115317015761 0ustar www-datawww-data= Rakefile Format (as of version 0.8.7) First of all, there is no special format for a Rakefile. A Rakefile contains executable Ruby code. Anything legal in a ruby script is allowed in a Rakefile. Now that we understand there is no special syntax in a Rakefile, there are some conventions that are used in a Rakefile that are a little unusual in a typical Ruby program. Since a Rakefile is tailored to specifying tasks and actions, the idioms used in a Rakefile are designed to support that. So, what goes into a Rakefile? == Tasks Tasks are the main unit of work in a Rakefile. Tasks have a name (usually given as a symbol or a string), a list of prerequisites (more symbols or strings) and a list of actions (given as a block). === Simple Tasks A task is declared by using the +task+ method. +task+ takes a single parameter that is the name of the task. task :name === Tasks with Prerequisites Any prerequisites are given as a list (enclosed in square brackets) following the name and an arrow (=>). task :name => [:prereq1, :prereq2] NOTE: Although this syntax looks a little funky, it is legal Ruby. We are constructing a hash where the key is :name and the value for that key is the list of prerequisites. It is equivalent to the following ... hash = Hash.new hash[:name] = [:prereq1, :prereq2] task(hash) === Tasks with Actions Actions are defined by passing a block to the +task+ method. Any Ruby code can be placed in the block. The block may reference the task object via the block parameter. task :name => [:prereq1, :prereq2] do |t| # actions (may reference t) end === Multiple Definitions A task may be specified more than once. Each specification adds its prerequisites and actions to the existing definition. This allows one part of a rakefile to specify the actions and a different rakefile (perhaps separately generated) to specify the dependencies. For example, the following is equivalent to the single task specification given above. task :name task :name => [:prereq1] task :name => [:prereq2] task :name do |t| # actions end == File Tasks Some tasks are designed to create a file from one or more other files. Tasks that generate these files may be skipped if the file already exists. File tasks are used to specify file creation tasks. File tasks are declared using the +file+ method (instead of the +task+ method). In addition, file tasks are usually named with a string rather than a symbol. The following file task creates a executable program (named +prog+) given two object files named a.o and b.o. The tasks for creating a.o and b.o are not shown. file "prog" => ["a.o", "b.o"] do |t| sh "cc -o #{t.name} #{t.prerequisites.join(' ')}" end == Directory Tasks It is common to need to create directories upon demand. The +directory+ convenience method is a short-hand for creating a FileTask that creates the directory. For example, the following declaration ... directory "testdata/examples/doc" is equivalent to ... file "testdata" do |t| mkdir t.name end file "testdata/examples" do |t| mkdir t.name end file "testdata/examples/doc" do |t| mkdir t.name end The +directory+ method does not accept prerequisites or actions, but both prerequisites and actions can be added later. For example ... directory "testdata" file "testdata" => ["otherdata"] file "testdata" do cp Dir["standard_data/*.data"], "testdata" end == Tasks with Parallel Prerequisites Rake allows parallel execution of prerequisites using the following syntax: multitask :copy_files => [:copy_src, :copy_doc, :copy_bin] do puts "All Copies Complete" end In this example, +copy_files+ is a normal rake task. Its actions are executed whenever all of its prerequisites are done. The big difference is that the prerequisites (+copy_src+, +copy_bin+ and +copy_doc+) are executed in parallel. Each of the prerequisites are run in their own Ruby thread, possibly allowing faster overall runtime. === Secondary Prerequisites If any of the primary prerequisites of a multitask have common secondary prerequisites, all of the primary/parallel prerequisites will wait until the common prerequisites have been run. For example, if the copy_xxx tasks have the following prerequisites: task :copy_src => [:prep_for_copy] task :copy_bin => [:prep_for_copy] task :copy_doc => [:prep_for_copy] Then the +prep_for_copy+ task is run before starting all the copies in parallel. Once +prep_for_copy+ is complete, +copy_src+, +copy_bin+, and +copy_doc+ are all run in parallel. Note that +prep_for_copy+ is run only once, even though it is referenced in multiple threads. === Thread Safety The Rake internal data structures are thread-safe with respect to the multitask parallel execution, so there is no need for the user to do extra synchronization for Rake's benefit. However, if there are user data structures shared between the parallel prerequisites, the user must do whatever is necessary to prevent race conditions. == Tasks with Arguments Prior to version 0.8.0, rake was only able to handle command line arguments of the form NAME=VALUE that were passed into Rake via the ENV hash. Many folks had asked for some kind of simple command line arguments, perhaps using "--" to separate regular task names from argument values on the command line. The problem is that there was no easy way to associate positional arguments on the command line with different tasks. Suppose both tasks :a and :b expect a command line argument: does the first value go with :a? What if :b is run first? Should it then get the first command line argument. Rake 0.8.0 solves this problem by explicitly passing values directly to the tasks that need them. For example, if I had a release task that required a version number, I could say: rake release[0.8.2] And the string "0.8.2" will be passed to the :release task. Multiple arguments can be passed by separating them with a comma, for example: rake name[john,doe] Just a few words of caution. The rake task name and its arguments need to be a single command line argument to rake. This generally means no spaces. If spaces are needed, then the entire rake + argument string should be quoted. Something like this: rake "name[billy bob, smith]" (Quoting rules vary between operating systems and shells, so make sure you consult the proper docs for your OS/shell). === Tasks Arguments and the Environment Task argument values can also be picked up from the environment. For example, if the "release" task expected a parameter named "release_version", then either rake release[0.8.2] or RELEASE_VERSION=0.8.2 rake release or, alternatively rake release RELEASE_VERSION=0.8.2 will work. Environment variable names must either match the task parameter exactly, or match an all-uppercase version of the task parameter. NOTE: A variable declared within a rake command will not persist in the environment: $ export VALUE=old $ rake print_value VALUE=new new $ rake print_value old === Tasks that Expect Parameters Parameters are only given to tasks that are setup to expect them. In order to handle named parameters, the task declaration syntax for tasks has been extended slightly. For example, a task that needs a first name and last name might be declared as: task :name, [:first_name, :last_name] The first argument is still the name of the task (:name in this case). The next two arguments are the names of the parameters expected by :name in an array (:first_name and :last_name in the example). To access the values of the parameters, the block defining the task behaviour can now accept a second parameter: task :name, [:first_name, :last_name] do |t, args| puts "First name is #{args.first_name}" puts "Last name is #{args.last_name}" end The first argument of the block "t" is always bound to the current task object. The second argument "args" is an open-struct like object that allows access to the task arguments. Extra command line arguments to a task are ignored. Missing command line arguments are picked up from matching environment variables. If there are no matching environment variables, they are given the nil value. If you wish to specify default values for the arguments, you can use the with_defaults method in the task body. Here is the above example where we specify default values for the first and last names: task :name, [:first_name, :last_name] do |t, args| args.with_defaults(:first_name => "John", :last_name => "Dough") puts "First name is #{args.first_name}" puts "Last name is #{args.last_name}" end === Tasks that Expect Parameters and Have Prerequisites Tasks that use parameters have a slightly different format for prerequisites. Use the arrow notation to indicate the prerequisites for tasks with arguments. For example: task :name, [:first_name, :last_name] => [:pre_name] do |t, args| args.with_defaults(:first_name => "John", :last_name => "Dough") puts "First name is #{args.first_name}" puts "Last name is #{args.last_name}" end === Deprecated Task Parameters Format There is an older format for declaring task parameters that omitted the task argument array and used the :needs keyword to introduce the dependencies. That format is still supported for compatibility, but is not recommended for use. The older format may be dropped in future versions of rake. == Accessing Task Programmatically Sometimes it is useful to manipulate tasks programmatically in a Rakefile. To find a task object, use the :[] operator on the Rake::Task. === Programmatic Task Example For example, the following Rakefile defines two tasks. The :doit task simply prints a simple "DONE" message. The :dont class will lookup the doit class and remove (clear) all of its prerequisites and actions. task :doit do puts "DONE" end task :dont do Rake::Task[:doit].clear end Running this example: $ rake doit (in /Users/jim/working/git/rake/x) DONE $ rake dont doit (in /Users/jim/working/git/rake/x) $ The ability to programmatically manipulate tasks gives rake very powerful meta-programming capabilities w.r.t. task execution, but should be used with caution. == Rules When a file is named as a prerequisite, but does not have a file task defined for it, Rake will attempt to synthesize a task by looking at a list of rules supplied in the Rakefile. Suppose we were trying to invoke task "mycode.o", but no task is defined for it. But the rakefile has a rule that look like this ... rule '.o' => ['.c'] do |t| sh "cc #{t.source} -c -o #{t.name}" end This rule will synthesize any task that ends in ".o". It has a prerequisite a source file with an extension of ".c" must exist. If Rake is able to find a file named "mycode.c", it will automatically create a task that builds "mycode.o" from "mycode.c". If the file "mycode.c" does not exist, rake will attempt to recursively synthesize a rule for it. When a task is synthesized from a rule, the +source+ attribute of the task is set to the matching source file. This allows us to write rules with actions that reference the source file. === Advanced Rules Any regular expression may be used as the rule pattern. Additionally, a proc may be used to calculate the name of the source file. This allows for complex patterns and sources. The following rule is equivalent to the example above. rule( /\.o$/ => [ proc {|task_name| task_name.sub(/\.[^.]+$/, '.c') } ]) do |t| sh "cc #{t.source} -c -o #{t.name}" end NOTE: Because of a _quirk_ in Ruby syntax, parenthesis are required on *rule* when the first argument is a regular expression. The following rule might be used for Java files ... rule '.class' => [ proc { |tn| tn.sub(/\.class$/, '.java').sub(/^classes\//, 'src/') } ] do |t| java_compile(t.source, t.name) end NOTE: +java_compile+ is a hypothetical method that invokes the java compiler. == Importing Dependencies Any ruby file (including other rakefiles) can be included with a standard Ruby +require+ command. The rules and declarations in the required file are just added to the definitions already accumulated. Because the files are loaded _before_ the rake targets are evaluated, the loaded files must be "ready to go" when the rake command is invoked. This make generated dependency files difficult to use. By the time rake gets around to updating the dependencies file, it is too late to load it. The +Rake.import+ command addresses this by specifying a file to be loaded _after_ the main rakefile is loaded, but _before_ any targets on the command line are invoked. In addition, if the file name matches an explicit task, that task is invoked before loading the file. This allows dependency files to be generated and used in a single rake command invocation. NOTE: Starting in Rake version 0.9.0, the top level +import+ command is deprecated and we recommend using the scoped "+Rake.import+" command mentioned above. Future versions of Rake will drop support for the top level +import+ command. === Example: require 'rake/loaders/makefile' file ".depends.mf" => [SRC_LIST] do |t| sh "makedepend -f- -- #{CFLAGS} -- #{t.prerequisites} > #{t.name}" end Rake.import ".depends.mf" If ".depends" does not exist, or is out of date w.r.t. the source files, a new ".depends" file is generated using +makedepend+ before loading. == Comments Standard Ruby comments (beginning with "#") can be used anywhere it is legal in Ruby source code, including comments for tasks and rules. However, if you wish a task to be described using the "-T" switch, then you need to use the +desc+ command to describe the task. === Example: desc "Create a distribution package" task :package => [ ... ] do ... end The "-T" switch (or "--tasks" if you like to spell things out) will display a list of tasks that have a description. If you use +desc+ to describe your major tasks, you have a semi-automatic way of generating a summary of your Rake file. traken$ rake -T (in /home/.../rake) rake clean # Remove any temporary products. rake clobber # Remove any generated file. rake clobber_rdoc # Remove rdoc products rake contrib_test # Run tests for contrib_test rake default # Default Task rake install # Install the application rake lines # Count lines in the main rake file rake rdoc # Build the rdoc HTML Files rake rerdoc # Force a rebuild of the RDOC files rake test # Run tests rake testall # Run all test targets Only tasks with descriptions will be displayed with the "-T" switch. Use "-P" (or "--prereqs") to get a list of all tasks and their prerequisites. == Namespaces As projects grow (and along with it, the number of tasks), it is common for task names to begin to clash. For example, if you might have a main program and a set of sample programs built by a single Rakefile. By placing the tasks related to the main program in one namespace, and the tasks for building the sample programs in a different namespace, the task names will not will not interfere with each other. For example: namespace "main" do task :build do # Build the main program end end namespace "samples" do task :build do # Build the sample programs end end task :build => ["main:build", "samples:build"] Referencing a task in a separate namespace can be achieved by prefixing the task name with the namespace and a colon (e.g. "main:build" refers to the :build task in the +main+ namespace). Nested namespaces are supported, so Note that the name given in the +task+ command is always the unadorned task name without any namespace prefixes. The +task+ command always defines a task in the current namespace. === FileTasks File task names are not scoped by the namespace command. Since the name of a file task is the name of an actual file in the file system, it makes little sense to include file task names in name space. Directory tasks (created by the +directory+ command) are a type of file task and are also not affected by namespaces. === Name Resolution When looking up a task name, rake will start with the current namespace and attempt to find the name there. If it fails to find a name in the current namespace, it will search the parent namespaces until a match is found (or an error occurs if there is no match). The "rake" namespace is a special implicit namespace that refers to the toplevel names. If a task name begins with a "^" character, the name resolution will start in the parent namespace. Multiple "^" characters are allowed. Here is an example file with multiple :run tasks and how various names resolve in different locations. task :run namespace "one" do task :run namespace "two" do task :run # :run => "one:two:run" # "two:run" => "one:two:run" # "one:two:run" => "one:two:run" # "one:run" => "one:run" # "^run" => "one:run" # "^^run" => "rake:run" (the top level task) # "rake:run" => "rake:run" (the top level task) end # :run => "one:run" # "two:run" => "one:two:run" # "^run" => "rake:run" end # :run => "rake:run" # "one:run" => "one:run" # "one:two:run" => "one:two:run" == FileLists FileLists are the way Rake manages lists of files. You can treat a FileList as an array of strings for the most part, but FileLists support some additional operations. === Creating a FileList Creating a file list is easy. Just give it the list of file names: fl = FileList['file1.rb', file2.rb'] Or give it a glob pattern: fl = FileList['*.rb'] == Odds and Ends === do/end versus { } Blocks may be specified with either a +do+/+end+ pair, or with curly braces in Ruby. We _strongly_ recommend using +do+/+end+ to specify the actions for tasks and rules. Because the rakefile idiom tends to leave off parentheses on the task/file/rule methods, unusual ambiguities can arise when using curly braces. For example, suppose that the method +object_files+ returns a list of object files in a project. Now we use +object_files+ as the prerequisites in a rule specified with actions in curly braces. # DON'T DO THIS! file "prog" => object_files { # Actions are expected here (but it doesn't work)! } Because curly braces have a higher precedence than +do+/+end+, the block is associated with the +object_files+ method rather than the +file+ method. This is the proper way to specify the task ... # THIS IS FINE file "prog" => object_files do # Actions go here end == Rakefile Path When issuing the rake command in a terminal, Rake will look for a Rakefile in the current directory. If a Rakefile is not found, it will search parent directories until one is found. For example, if a Rakefile resides in the project/ directory, moving deeper into the project's directory tree will not have an adverse effect on rake tasks: $ pwd /home/user/project $ cd lib/foo/bar $ pwd /home/user/project/lib/foo/bar $ rake run_pwd /home/user/project As far as rake is concerned, all tasks are run from the directory in which the Rakefile resides. === Multiple Rake Files Not all tasks need to be included in a single Rakefile. Additional rake files (with the file extension ".rake") may be placed in rakelib directory located at the top level of a project (i.e. the same directory that contains the main Rakefile). Also, rails projects may include additional rake files in the lib/tasks directory. ---- == See * README.rdoc -- Main documentation for Rake. rake-10.0.4/doc/release_notes/0000755000004100000410000000000012124115317016140 5ustar www-datawww-datarake-10.0.4/doc/release_notes/rake-0.9.1.rdoc0000644000004100000410000000300712124115317020376 0ustar www-datawww-data= Rake 0.9.1 Released Rake version 0.9.1 has a number of bug fixes and enhancments (see below for more details). Additionally, the internals have be slightly restructured and improved. == Changes Rake 0.9.1 adds back the global DSL methods, but with deprecation messages. This allows Rake 0.9.1 to be used with older rakefiles with warning messages. == 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://rake.rubyforge.org/ 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 alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... * James M. Lawrence (quix) * Roger Pack * Cezary Baginski * Sean Scot August Moon * R.T. Lechow * Alex Chaffee * James Tucker * Matthias Lüdtke * Santiago Pastorino Also, bit thanks to Eric Hodel for assisting with getting this release out the door (where "assisting" includes, but is not by any means limited to, "pushing" me to get it done). -- Jim Weirich rake-10.0.4/doc/release_notes/rake-0.7.2.rdoc0000644000004100000410000000734312124115317020404 0ustar www-datawww-data= Rake 0.7.2 Released Version 0.7.2 supplies a bug fix and a few minor enhancements. In particular, the new version fixes an incompatibility with the soon to be released Ruby 1.8.6. We strongly recommend upgrading to Rake 0.7.2 in order to be compatible with the new version of Ruby. == Changes === Bug Fixes in 0.7.2 There are quite a number of bug fixes in the new 0.7.2 version of Rake: * Removed dependency on internal fu_xxx functions from FileUtils. * Error messages are now send to stderr rather than stdout (from Payton Quackenbush). * Better error handling on invalid command line arguments (from Payton Quackenbush). * Fixed some bugs where the application object was going to the global appliation instead of using its own data. * Fixed the method name leak from FileUtils (bug found by Glenn Vanderburg). * Added test for noop, bad_option and verbose flags to sh command. * Added a description to the gem task in GemPackageTask. * Fixed a bug when rules have multiple prerequisites (patch by Joel VanderWerf) * Added the handful of RakeFileUtils to the private method as well. === New Features in 0.7.2 The following new features are available in Rake version 0.7.2: * Added square and curly bracket patterns to FileList#include (Tilman Sauerbeck). * FileLists can now pass a block to FileList#exclude to exclude files based on calculated values. * Added plain filename support to rule dependents (suggested by Nobu Nakada). * Added pathmap support to rule dependents. In other words, if a pathmap format (beginning with a '%') is given as a Rake rule dependent, then the name of the depend will be the name of the target with the pathmap format applied. * Added a 'tasks' method to a namespace to get a list of tasks associated with the namespace. * Added tar_command and zip_command options to the Package task. * The clean task will no longer delete 'core' if it is a directory. === Internal Rake Improvements The following changes will are mainly internal improvements and refactorings and have little effect on the end user. But they may be of interest to the general public. * Added rcov task and updated unit testing for better code coverage. * Added a 'shame' task to the Rakefile. * Added rake_extension to handle detection of extension collisions. * Added a protected 'require "rubygems"' to test/test_application to unbreak cruisecontrol.rb. * Removed rake_dup. Now we just simply rescue a bad dup. * Refactored the FileList reject logic to remove duplication. * Removed if __FILE__ at the end of the rake.rb file. == 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://rake.rubyforge.org/ Download:: http://rubyforge.org/project/showfiles.php?group_id=50 == Thanks As usual, it was input from users that drove a alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... * Payton Quackenbush -- For several error handling improvements. * Glenn Vanderburg -- For finding and fixing the method name leak from FileUtils. * Joel VanderWerf -- for finding and fixing a bug in the handling of multiple prerequisites. * Tilman Sauerbeck -- For some enhancing FileList to support more advanced file globbing. * Nobu Nakada -- For suggesting plain file name support to rule dependents. -- Jim Weirich rake-10.0.4/doc/release_notes/rake-0.5.0.rdoc0000644000004100000410000000314212124115317020371 0ustar www-datawww-data= Rake 0.5.0 Released It has been a long time in coming, but we finally have a new version of Rake available. == Changes * Fixed bug where missing intermediate file dependencies could cause an abort with --trace or --dry-run. (Brian Candler) * Recursive rules are now supported (Tilman Sauerbeck). * Added tar.gz and tar.bz2 support to package task (Tilman Sauerbeck). * Added warning option for the Test Task (requested by Eric Hodel). * The jamis rdoc template is only used if it exists. * Added fix for Ruby 1.8.2 test/unit and rails problem. * Added contributed rake man file. (Jani Monoses) * Fixed documentation that was lacking the Rake module name (Tilman Sauerbeck). == 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://rake.rubyforge.org/ Download:: http://rubyforge.org/project/showfiles.php?group_id=50 == Thanks Lots of people provided input to this release. Thanks to Tilman Sauerbeck for numerous patches, documentation fixes and suggestions. And for also pushing me to get this release out. Also, thanks to Brian Candler for the finding and fixing --trace/dry-run fix. That was an obscure bug. Also to Eric Hodel for some good suggestions. -- Jim Weirich rake-10.0.4/doc/release_notes/rake-10.0.1.rdoc0000644000004100000410000001436412124115317020456 0ustar www-datawww-data= Rake 10.0.1 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 10.0 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 --classic-namespace option is no longer supported. * Global constants are no longer supported. This includes Task, FileTask, FileCreationTask and RakeApp). 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 main object. Since main 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 Rake::DSL into your own classes and modules. * The deprecated syntax for task arguments (the one using :needs) has been removed. * The --reduce-compat flag has been removed (it's not needed anymore). * The deprecated rake/sys.rb library has been removed. * The deprecated rake/rdoctask.rb library has been removed. RDoc supplies its own rake task now. * The deprecated rake/gempackagetask.rb 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) Since Rake 10 includes the changes from the last version of Rake 9, we'll repeat the changes for version 0.9.3 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) == 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 rake-10.0.4/doc/release_notes/rake-0.7.1.rdoc0000644000004100000410000000362712124115317020404 0ustar www-datawww-data= Rake 0.7.1 Released Version 0.7.1 supplies a bug fix and a few minor enhancements. == Changes === Bug Fixes in 0.7.1 * Changes in the exception reported for the FileUtils.ln caused safe_ln to fail with a NotImplementedError. Rake 0.7.1 will now catch that error or any StandardError and properly fall back to using +cp+. === New Features in 0.7.1 * You can filter the results of the --task option by supplying an optional regular expression. This allows the user to easily find a particular task name in a long list of possible names. * Transforming procs in a rule may now return a list of prerequisites. This allows more flexible rule formation. * FileList and String now support a +pathmap+ melthod that makes the transforming paths a bit easier. See the API docs for +pathmap+ for details. * The -f option without a value will disable the search for a Rakefile. This allows the Rakefile to be defined entirely in a library (and loaded with the -r option). The current working directory is not changed when this is done. == 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://rake.rubyforge.org/ Download:: http://rubyforge.org/project/showfiles.php?group_id=50 == Thanks As usual, it was input from users that drove a alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... * James Britt and Assaph Mehr for reporting and helping to debug the safe_ln issue. -- Jim Weirich rake-10.0.4/doc/release_notes/rake-0.8.2.rdoc0000644000004100000410000001346512124115317020407 0ustar www-datawww-data= Rake 0.8.2 Released Rake version 0.8.2 is a new release of rake that includes a number of new features and numerous bug fixes. == Changes === New Features in Version 0.8.2 * Switched from getoptlong to optparse (patches supplied by Edwin Pratomo). * The -T option will now attempt to dynamically sense the size of the terminal. The -T output will only self-truncate if the output is a tty. However, if RAKE_COLUMNS is explicitly set, it will be honored in any case. (Patch provided by Gavin Stark). * The following public methods have been added to rake task objects: * task.clear -- Clear both the prerequisites and actions of the target rake task. * task.clear_prerequisites -- Clear all the existing prerequisites from the target rake task. * task.clear_actions -- Clear all the existing actions from the target rake task. * task.reenable -- Re-enable a task, allowing its actions to be executed again if the task is invoked. * Changed RDoc test task to have no default template. This makes it easier for the tempate to pick up the template from the environment. * Default values for task arguments can easily be specified with the :with_defaults method. (Idea for default argument merging supplied by (Adam Q. Salter) === Bug Fixes in Version 0.8.2 * Fixed bug in package task so that it will include the subdir directory in the package for testing. (Bug found by Adam Majer) * Fixed filename dependency order bug in test_inspect_pending and test_to_s_pending. (Bug found by Adam Majer) * Fixed check for file utils options to make them immune to the symbol/string differences. (Patch supplied by Edwin Pratomo) * Fixed bug with rules involving multiple source, where only the first dependency of a rule has any effect (Patch supplied by Emanuel Indermühle) * FileList#clone and FileList#dup have better sematics w.r.t. taint and freeze. * Changed from using Mutex to Monitor. Evidently Mutex causes thread join errors when Ruby is compiled with -disable-pthreads. (Patch supplied by Ittay Dror) * Fixed bug in makefile parser that had problems with extra spaces in file task names. (Patch supplied by Ittay Dror) == Other changes in Version 0.8.2 * Added ENV var to rake's own Rakefile to prevent OS X from including extended attribute junk in the rake package tar file. (Bug found by Adam Majer) * Added a performance patch for reading large makefile dependency files. (Patch supplied by Ittay Dror) == 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://rake.rubyforge.org/ Download:: http://rubyforge.org/project/showfiles.php?group_id=50 == Task Argument Examples Prior to version 0.8.0, rake was only able to handle command line arguments of the form NAME=VALUE that were passed into Rake via the ENV hash. Many folks had asked for some kind of simple command line arguments, perhaps using "--" to separate regular task names from argument values on the command line. The problem is that there was no easy way to associate positional arguments on the command line with different tasks. Suppose both tasks :a and :b expect a command line argument: does the first value go with :a? What if :b is run first? Should it then get the first command line argument. Rake 0.8.0 solves this problem by explicitly passing values directly to the tasks that need them. For example, if I had a release task that required a version number, I could say: rake release[0.8.2] And the string "0.8.2" will be passed to the :release task. Multiple arguments can be passed by separating them with a comma, for example: rake name[john,doe] Just a few words of caution. The rake task name and its arguments need to be a single command line argument to rake. This generally means no spaces. If spaces are needed, then the entire rake + argument string should be quoted. Something like this: rake "name[billy bob, smith]" (Quoting rules vary between operating systems and shells, so make sure you consult the proper docs for your OS/shell). === Tasks that Expect Parameters Parameters are only given to tasks that are setup to expect them. In order to handle named parameters, the task declaration syntax for tasks has been extended slightly. For example, a task that needs a first name and last name might be declared as: task :name, :first_name, :last_name The first argument is still the name of the task (:name in this case). The next to argumements are the names of the parameters expected by :name (:first_name and :last_name in the example). To access the values of the paramters, the block defining the task behaviour can now accept a second parameter: task :name, :first_name, :last_name do |t, args| puts "First name is #{args.first_name}" puts "Last name is #{args.last_name}" end The first argument of the block "t" is always bound to the current task object. The second argument "args" is an open-struct like object that allows access to the task arguments. Extra command line arguments to a task are ignored. Missing command line arguments are given the nil value. == Thanks As usual, it was input from users that drove a alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... * Edwin Pratomo * Gavin Stark * Adam Q. Salter * Adam Majer * Emanuel Indermühle * Ittay Dror * Bheeshmar Redheendran (for spending an afternoon with me debugging windows issues) -- Jim Weirich rake-10.0.4/doc/release_notes/rake-0.5.4.rdoc0000644000004100000410000000263112124115317020377 0ustar www-datawww-data= Rake 0.5.4 Released Time for some minor bug fixes and small enhancements == Changes Here are the changes for version 0.5.3 ... * Added double quotes to the test runner. This allows the location of the tests (and runner) to be in a directory path that contains spaces (e.g. "C:/Program Files/ruby/bin"). * Added .svn to default ignore list. Now subversion project metadata is automatically ignored by Rake's FileList. * Updated FileList#include to support nested arrays and filelists. FileLists are flat lists of file names. Using a FileList in an include will flatten out the nested file 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://rake.rubyforge.org/ Download:: http://rubyforge.org/project/showfiles.php?group_id=50 == Thanks As usual, it was input from users that drove a alot of these changes. Thanks to ... * Tilman Sauerbeck for the nested FileList suggestion. * Josh Knowles for pointing out the spaces in directory name problem. -- Jim Weirich rake-10.0.4/doc/release_notes/rake-0.9.2.2.rdoc0000644000004100000410000000337012124115317020542 0ustar www-datawww-data= Rake 0.9.3 Released Rake version 0.9.3 is mainly bug fixes. == Changes * The rake test loader now removes arguments it has processed. Issue #51 * Rake::TaskArguments now responds to #values_at * RakeFileUtils.verbose_flag = nil silences output the same as 0.8.7 * Rake tests are now directory-independent * Rake tests are no longer require flexmock * Commands constant is no longer polluting top level namespace. * Show only the interesting portion of the backtrace by default (James M. Lawrence). * Added --reduce-compat option to remove backward compatible DSL hacks (James M. Lawrence). == 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://rake.rubyforge.org/ 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 alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... * James M. Lawrence (quix) * Roger Pack * Cezary Baginski * Sean Scot August Moon * R.T. Lechow * Alex Chaffee * James Tucker * Matthias Lüdtke * Santiago Pastorino Also, bit thanks to Eric Hodel for assisting with getting this release out the door (where "assisting" includes, but is not by any means limited to, "pushing" me to get it done). -- Jim Weirich rake-10.0.4/doc/release_notes/rake-0.8.6.rdoc0000644000004100000410000000314512124115317020405 0ustar www-datawww-data= Rake 0.8.6 Released Rake version 0.8.5 introduced greatly improved support for executing commands on Windows. The "sh" command now has the same semantics on Windows that it has on Unix based platforms. Rake version 0.8.6 includes minor fixes the the RDoc generation. == Changes === New Features / Enhancements in Version 0.8.5 * Improved implementation of the Rake system command for Windows. (patch from James M. Lawrence/quix) * Support for Ruby 1.9's improved system command. (patch from James M. Lawrence/quix) * Rake now includes the configured extension when invoking an executable (Config::CONFIG['EXEEXT]) === Bug Fixes in Version 0.8.5 * Environment variable keys are now correctly cased (it matters in some implementations). == 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://rake.rubyforge.org/ 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 alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... * James M. Lawrence/quix * Luis Lavena -- Jim Weirich rake-10.0.4/doc/release_notes/rake-0.8.0.rdoc0000644000004100000410000000762012124115317020401 0ustar www-datawww-data= Rake 0.8.0/0.8.1 Released Rake version 0.8.0 is a new release of rake that includes serveral new features. == Changes === New Features in Version 0.8.0 * Tasks can now receive command line parameters. See the examples below for more details. * Comments are limited to 80 columns on output, but full comments can be seen by using the -D parameter. (feature suggested by Jamis Buck). * Explicit exit(n) calls will now set the exit status to n. (patch provided by Stephen Touset). * Rake is now compatible with Ruby 1.9. Version 0.8.1 is a minor update that includes additional Ruby 1.9 compatibility fixes. == 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://rake.rubyforge.org/ Download:: http://rubyforge.org/project/showfiles.php?group_id=50 == Task Argument Examples Prior to version 0.8.0, rake was only able to handle command line arguments of the form NAME=VALUE that were passed into Rake via the ENV hash. Many folks had asked for some kind of simple command line arguments, perhaps using "--" to separate regular task names from argument values on the command line. The problem is that there was no easy way to associate positional arguments on the command line with different tasks. Suppose both tasks :a and :b expect a command line argument: does the first value go with :a? What if :b is run first? Should it then get the first command line argument. Rake 0.8.0 solves this problem by explicitly passing values directly to the tasks that need them. For example, if I had a release task that required a version number, I could say: rake release[0.8.0] And the string "0.8.0" will be passed to the :release task. Multiple arguments can be passed by separating them with a comma, for example: rake name[john,doe] Just a few words of caution. The rake task name and its arguments need to be a single command line argument to rake. This generally means no spaces. If spaces are needed, then the entire rake + argument string should be quoted. Something like this: rake "name[billy bob, smith]" (Quoting rules vary between operating systems and shells, so make sure you consult the proper docs for your OS/shell). === Tasks that Expect Parameters Parameters are only given to tasks that are setup to expect them. In order to handle named parameters, the task declaration syntax for tasks has been extended slightly. For example, a task that needs a first name and last name might be declared as: task :name, :first_name, :last_name The first argument is still the name of the task (:name in this case). The next to argumements are the names of the parameters expected by :name (:first_name and :last_name in the example). To access the values of the paramters, the block defining the task behaviour can now accept a second parameter: task :name, :first_name, :last_name do |t, args| puts "First name is #{args.first_name}" puts "Last name is #{args.last_name}" end The first argument of the block "t" is always bound to the current task object. The second argument "args" is an open-struct like object that allows access to the task arguments. Extra command line arguments to a task are ignored. Missing command line arguments are given the nil value. == Thanks As usual, it was input from users that drove a alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... * Jamis Buck (for comment formatting suggestions) * Stephen Touset (for exit status patch). -- Jim Weirich rake-10.0.4/doc/release_notes/rake-0.7.3.rdoc0000755000004100000410000000235512124115317020406 0ustar www-datawww-data= Rake 0.7.3 Released Rake version 0.7.3 is a minor release that includes some refactoring to better support custom Rake applications. == Changes === New Features in Version 0.7.3 * Added the +init+ and +top_level+ methods to make the creation of custom Rake applications a bit easier. E.g. gem 'rake', ">= 0.7.3" require 'rake' Rake.application.init('myrake') task :default do something_interesting end Rake.application.top_level == 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://rake.rubyforge.org/ Download:: http://rubyforge.org/project/showfiles.php?group_id=50 == Thanks As usual, it was input from users that drove a alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... -- Jim Weirich rake-10.0.4/doc/release_notes/rake-10.0.2.rdoc0000644000004100000410000001455412124115317020460 0ustar www-datawww-data= Rake 10.0.2 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 --classic-namespace option is no longer supported. * Global constants are no longer supported. This includes Task, FileTask, FileCreationTask and RakeApp). 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 main object. Since main 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 Rake::DSL into your own classes and modules. * The deprecated syntax for task arguments (the one using :needs) has been removed. * The --reduce-compat flag has been removed (it's not needed anymore). * The deprecated rake/sys.rb library has been removed. * The deprecated rake/rdoctask.rb library has been removed. RDoc supplies its own rake task now. * The deprecated rake/gempackagetask.rb 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 rake-10.0.4/doc/release_notes/rake-0.9.5.rdoc0000644000004100000410000000576712124115317020421 0ustar www-datawww-data= Rake 0.9.5 Released Rake version 0.9.5 contains a number of bug fixes. == Changes === 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 (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 (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 (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 alot of these changes. The following people either 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 rake-10.0.4/doc/release_notes/rake-10.0.3.rdoc0000644000004100000410000001455412124115317020461 0ustar www-datawww-data= 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 --classic-namespace option is no longer supported. * Global constants are no longer supported. This includes Task, FileTask, FileCreationTask and RakeApp). 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 main object. Since main 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 Rake::DSL into your own classes and modules. * The deprecated syntax for task arguments (the one using :needs) has been removed. * The --reduce-compat flag has been removed (it's not needed anymore). * The deprecated rake/sys.rb library has been removed. * The deprecated rake/rdoctask.rb library has been removed. RDoc supplies its own rake task now. * The deprecated rake/gempackagetask.rb 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 rake-10.0.4/doc/release_notes/rake-0.7.0.rdoc0000644000004100000410000000627212124115317020402 0ustar www-datawww-data= Rake 0.7.0 Released These changes for Rake have been brewing for a long time. Here they are, I hope you enjoy them. == Changes === New Features * Name space support for task names (see below). * Prerequisites can be executed in parallel (see below). * Added safe_ln support for openAFS (via Ludvig Omholt). * RDoc defaults to internal (in-process) invocation. The old behavior is still available by setting the +external+ flag to true. * Rakefiles are now loaded with the expanded path to prevent accidental polution from the Ruby load path. * Task objects my now be used in prerequisite lists directly. * Task objects (in addition to task names) may now be included in the prerequisite list of a task. * Internals cleanup and refactoring. === Bug Fixes * Compatibility fixes for Ruby 1.8.4 FileUtils changes. === Namespaces Tasks can now be nested inside their own namespaces. Tasks within one namespace will not accidently interfer with tasks named in a different namespace. For example: namespace "main" do task :build do # Build the main program end end namespace "samples" do task :build do # Build the sample programs end end task :build_all => ["main:build", "samples:build"] Even though both tasks are named :build, they are separate tasks in their own namespaces. The :build_all task (defined in the toplevel namespace) references both build tasks in its prerequisites. You may invoke each of the individual build tasks with the following commands: rake main:build rake samples:build Or invoke both via the :build_all command: rake build_all Namespaces may be nested arbitrarily. Since the name of file tasks correspond to the name of a file in the external file system, FileTasks are not affected by the namespaces. See the Rakefile format documentation (in the Rake API documents) for more information. === Parallel Tasks Sometimes you have several tasks that can be executed in parallel. By specifying these tasks as prerequisites to a +multitask+ task. In the following example the tasks copy_src, copy_doc and copy_bin will all execute in parallel in their own thread. multitask :copy_files => [:copy_src, :copy_doc, :copy_bin] do puts "All Copies Complete" end == 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://rake.rubyforge.org/ Download:: http://rubyforge.org/project/showfiles.php?group_id=50 == Thanks As usual, it was input from users that drove a alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... * Doug Young (inspriation for the parallel task) * David Heinemeier Hansson (for --trace message enhancement and for pushing for namespace support). * Ludvig Omholt (for the openAFS fix) -- Jim Weirich rake-10.0.4/doc/release_notes/rake-0.8.5.rdoc0000644000004100000410000000306612124115317020406 0ustar www-datawww-data= Rake 0.8.5 Released Rake version 0.8.5 is a new release of Rake with greatly improved support for executing commands on Windows. The "sh" command now has the same semantics on Windows that it has on Unix based platforms. == Changes === New Features / Enhancements in Version 0.8.5 * Improved implementation of the Rake system command for Windows. (patch from James M. Lawrence/quix) * Support for Ruby 1.9's improved system command. (patch from James M. Lawrence/quix) * Rake now includes the configured extension when invoking an executable (Config::CONFIG['EXEEXT]) === Bug Fixes in Version 0.8.5 * Environment variable keys are now correctly cased (it matters in some implementations). == 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://rake.rubyforge.org/ 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 alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... * James M. Lawrence/quix * Luis Lavena -- Jim Weirich rake-10.0.4/doc/release_notes/rake-0.9.6.rdoc0000644000004100000410000000674212124115317020414 0ustar www-datawww-data= Rake 0.9.6 Released Rake version 0.9.6 contains a number of fixes mainly for merging Rake into the Ruby source tree and fixing tests. == Changes === 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 (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 (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 (0.9.5) * --trace and --backtrace no longer swallow following task names. === Bug Fixes (0.9.6) * Better trace output when using a multi-threaded Rakefile. * Arg parsing is now consistent for tasks and multitasks. * Skip exit code test in versions of Ruby that don't support it well. Changes for better integration with the Ruby source tree: * Fix version literal for Ruby source tree build. * Better loading of libraries for testing in Ruby build. * Use the ruby version provided by Ruby's tests. == 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 alot of these changes. The following people either 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 rake-10.0.4/doc/release_notes/rake-0.9.0.rdoc0000644000004100000410000000700412124115317020376 0ustar www-datawww-data= Rake 0.9.0 Released Rake version 0.9.0 has a number of bug fixes and enhancments (see below for more details). Additionally, the internals have be slightly restructured and improved. == Changes === New Features / Enhancements / Bug Fixes in Version 0.9.0 * Rake now warns when the deprecated :needs syntax used (and suggests the proper syntax in the warning). * Moved Rake DSL commands to top level ruby object 'main'. Rake DSL commands are no longer private methods in Object. (Suggested by James M. Lawrence/quix) * Rake now uses case-insensitive comparisons to find the Rakefile on Windows. Based on patch by Roger Pack. * Rake now requires (instead of loads) files in the test task. Patch by Cezary Baginski. * Fixed typos. Patches by Sean Scot August Moon and R.T. Lechow. * Rake now prints the Rakefile directory only when it's different from the current directory. Patch by Alex Chaffee. * Improved rakefile_location discovery on Windows. Patch by James Tucker. * Rake now recognizes "Windows Server" as a windows system. Patch by Matthias Lüdtke * Rake::RDocTask is deprecated. Use RDoc::Task from RDoc 2.4.2+ (require 'rdoc/task') * Rake::GemPackageTask is deprecated. Use Gem::PackageTask (require 'rubygems/package_task') * Rake now outputs various messages to $stderr instead of $stdout. * Rake no longer emits warnings for Config. Patch by Santiago Pastorino. * Removed Rake's DSL methods from the top level scope. If you need to call 'task :xzy' in your code, include Rake::DSL into your class, or put the code in a Rake::DSL.environment do ... end block. * Split rake.rb into individual files. * Support for the --where (-W) flag for showing where a task is defined. * Fixed quoting in test task. (http://onestepback.org/redmine/issues/show/44, http://www.pivotaltracker.com/story/show/1223138) * Fixed the silent option parsing problem. (http://onestepback.org/redmine/issues/show/47) * Fixed :verbose=>false flag on sh and ruby commands. * Rake command line options may be given by default in a RAKEOPT environment variable. * Errors in Rake will now display the task invocation chain in effect at the time of the error. * Accepted change by warnickr to not expand test patterns in shell (allowing more files in the test suite). * Fixed that file tasks did not perform prereq lookups in scope (Redmine #57). == 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://rake.rubyforge.org/ 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 alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... * James M. Lawrence (quix) * Roger Pack * Cezary Baginski * Sean Scot August Moon * R.T. Lechow * Alex Chaffee * James Tucker * Matthias Lüdtke * Santiago Pastorino Also, bit thanks to Eric Hodel for assisting with getting this release out the door (where "assisting" includes, but is not by any means limited to, "pushing" me to get it done). -- Jim Weirich rake-10.0.4/doc/release_notes/rake-0.9.2.rdoc0000644000004100000410000000253512124115317020404 0ustar www-datawww-data= Rake 0.9.2 Released Rake version 0.9.2 has a few small fixes. See below for details. == Changes * Support for Ruby 1.8.6 was fixed. * Global DSL warnings now honor --no-deprecate == 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://rake.rubyforge.org/ 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 alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... * James M. Lawrence (quix) * Roger Pack * Cezary Baginski * Sean Scot August Moon * R.T. Lechow * Alex Chaffee * James Tucker * Matthias Lüdtke * Santiago Pastorino Also, bit thanks to Eric Hodel for assisting with getting this release out the door (where "assisting" includes, but is not by any means limited to, "pushing" me to get it done). -- Jim Weirich rake-10.0.4/doc/release_notes/rake-0.4.14.rdoc0000644000004100000410000000130512124115317020454 0ustar www-datawww-data= Rake 0.4.14 Released == Changes Version 0.4.14 is a compatibility fix to allow Rake's test task to work under Ruby 1.8.2. A change in the Test::Unit autorun feature prevented Rake from running any tests. This release fixes the problem. Rake 0.4.14 is the recommended release for anyone using Ruby 1.8.2. == 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 Home Page:: http://rake.rubyforge.org/ Download:: http://rubyforge.org/project/showfiles.php?group_id=50 rake-10.0.4/doc/release_notes/rake-0.9.3.rdoc0000644000004100000410000000527612124115317020412 0ustar www-datawww-data= Rake 0.9.3 Released Rake version 0.9.3 contains some new, backwards compatible features and a number of bug fixes. == Changes === New Features * 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 * 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. == 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 alot of these changes. The following people either 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 rake-10.0.4/doc/release_notes/rake-0.8.3.rdoc0000644000004100000410000000743712124115317020412 0ustar www-datawww-data= Rake 0.8.3 Released Rake version 0.8.3 is a bug-fix release of rake. == Changes === Bug Fixes in Version 0.8.3 * Enhanced the system directory detection in windows. We now check HOMEDRIVE/HOMEPATH and USERPROFILE if APPDATA isn't found. (Patch supplied by James Tucker). Rake no long aborts if it can't find the directory. * Added fix to handle ruby installations in directories with spaces in their name. == 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://rake.rubyforge.org/ Download:: http://rubyforge.org/project/showfiles.php?group_id=50 == Task Argument Examples Prior to version 0.8.0, rake was only able to handle command line arguments of the form NAME=VALUE that were passed into Rake via the ENV hash. Many folks had asked for some kind of simple command line arguments, perhaps using "--" to separate regular task names from argument values on the command line. The problem is that there was no easy way to associate positional arguments on the command line with different tasks. Suppose both tasks :a and :b expect a command line argument: does the first value go with :a? What if :b is run first? Should it then get the first command line argument. Rake 0.8.0 solves this problem by explicitly passing values directly to the tasks that need them. For example, if I had a release task that required a version number, I could say: rake release[0.8.3] And the string "0.8.3" will be passed to the :release task. Multiple arguments can be passed by separating them with a comma, for example: rake name[john,doe] Just a few words of caution. The rake task name and its arguments need to be a single command line argument to rake. This generally means no spaces. If spaces are needed, then the entire rake + argument string should be quoted. Something like this: rake "name[billy bob, smith]" (Quoting rules vary between operating systems and shells, so make sure you consult the proper docs for your OS/shell). === Tasks that Expect Parameters Parameters are only given to tasks that are setup to expect them. In order to handle named parameters, the task declaration syntax for tasks has been extended slightly. For example, a task that needs a first name and last name might be declared as: task :name, :first_name, :last_name The first argument is still the name of the task (:name in this case). The next to argumements are the names of the parameters expected by :name (:first_name and :last_name in the example). To access the values of the paramters, the block defining the task behaviour can now accept a second parameter: task :name, :first_name, :last_name do |t, args| puts "First name is #{args.first_name}" puts "Last name is #{args.last_name}" end The first argument of the block "t" is always bound to the current task object. The second argument "args" is an open-struct like object that allows access to the task arguments. Extra command line arguments to a task are ignored. Missing command line arguments are given the nil value. == Thanks As usual, it was input from users that drove a alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... * Edwin Pratomo * Gavin Stark * Adam Q. Salter * Adam Majer * Emanuel Indermühle * Ittay Dror * Bheeshmar Redheendran (for spending an afternoon with me debugging windows issues) -- Jim Weirich rake-10.0.4/doc/release_notes/rake-0.8.7.rdoc0000644000004100000410000000322512124115317020405 0ustar www-datawww-data= Rake 0.8.7 Released Rake version 0.8.5 introduced greatly improved support for executing commands on Windows. The "sh" command now has the same semantics on Windows that it has on Unix based platforms. Rake version 0.8.6 includes minor fixes the the RDoc generation. Rake version 0.8.7 includes a minor fix for JRuby running on windows. == Changes === New Features / Enhancements in Version 0.8.5 * Improved implementation of the Rake system command for Windows. (patch from James M. Lawrence/quix) * Support for Ruby 1.9's improved system command. (patch from James M. Lawrence/quix) * Rake now includes the configured extension when invoking an executable (Config::CONFIG['EXEEXT]) === Bug Fixes in Version 0.8.5 * Environment variable keys are now correctly cased (it matters in some implementations). == 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://rake.rubyforge.org/ 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 alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... * Charles Nutter -- Jim Weirich rake-10.0.4/doc/release_notes/rake-0.6.0.rdoc0000644000004100000410000001216012124115317020372 0ustar www-datawww-data= Rake 0.6.0 Released Its time for some long requested enhancements and lots of bug fixes ... And a whole new web page. == New Web Page The primary documentation for rake has moved from the RubyForge based wiki to its own Hieraki based web site. Constant spam on the wiki made it a difficult to keep clean. The new site will be easier to update and organize. Check out the new documentation at: http://docs.rubyrake.org We will be adding new documentation to the site as time goes on. In addition to the new docs page, make sure you check out Martin Fowlers article on rake at http://martinfowler.com/articles/rake.html == Changes === New Features * Multiple prerequisites on Rake rules now allowed. However, keep the following in mind: 1. All the prerequisites of a rule must be available before a rule is triggered, where "enabled" means (a) an existing file, (b) a defined rule, or (c) another rule which also must be trigger-able. 2. Rules are checked in order of definition, so it is important to order your rules properly. If a file can be created by two different rules, put the more specific rule first (otherwise the more general rule will trigger first and the specific one will never be triggered). 3. The source method now returns the name of the first prerequisite listed in the rule. sources returns the names of all the rule prerequisites, ordered as they are defined in the rule. If the task has other prerequisites not defined in the rule (but defined in an explicit task definition), then they will _not_ be included in the sources list. * FileLists may now use the egrep command. This popular enhancement is now a core part of the FileList object. If you want to get a list of all your to-dos, fixmes and TBD comments, add the following to your Rakefile. desc "Look for TODO and FIXME tags in the code" task :todo do FileList['**/*.rb'].egrep /#.*(FIXME|TODO|TBD)/ end * The investigation method was added to task object to dump out some important values. This makes it a bit easier to debug Rake tasks. For example, if you are having problems with a particular task, just print it out: task :huh do puts Rake::Task['huh'].investigation end * The Rake::TestTask class now supports a "ruby_opts" option to pass arbitrary ruby options to a test subprocess. === Some Incompatibilities * When using the ruby command to start a Ruby subprocess, the Ruby interpreter that is currently running rake is used by default. This makes it easier to use rake in an environment with multiple ruby installation. (Previously, the first ruby command found in the PATH was used). If you wish to chose a different Ruby interpreter, you can explicitly choose the interpreter via the sh command. * The major rake classes (Task, FileTask, FileCreationTask, RakeApp) have been moved out of the toplevel scope and are now accessible as Rake::Task, Rake::FileTask, Rake::FileCreationTask and Rake::Application. If your Rakefile directly references any one of these tasks, you may: 1. Update your Rakefile to use the new classnames 2. Use the --classic-namespace option on the rake command to get the old behavior, 3. Add require 'rake/classic_namespace' to the Rakefile to get the old behavior. rake will print a rather annoying warning whenever a deprecated class name is referenced without enabling classic namespace. === Bug Fixes * Several unit tests and functional tests were fixed to run better under windows. * Directory tasks are now a specialized version of a File task. A directory task will only be triggered if it doesn't exist. It will not be triggered if it is out of date w.r.t. any of its prerequisites. * Fixed a bug in the Rake::GemPackageTask class so that the gem now properly contains the platform name. * Fixed a bug where a prerequisite on a file task would cause an exception if the prerequisite did not exist. == 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://rake.rubyforge.org/ Download:: http://rubyforge.org/project/showfiles.php?group_id=50 == Thanks As usual, it was input from users that drove a alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... * Greg Fast (better ruby_opt test options) * Kelly Felkins (requested by better namespace support) * Martin Fowler (suggested Task.investigation) * Stuart Jansen (send initial patch for multiple prerequisites). * Masao Mutch (better support for non-ruby Gem platforms) * Philipp Neubeck (patch for file task exception fix) -- Jim Weirich rake-10.0.4/doc/release_notes/rake-10.0.0.rdoc0000644000004100000410000001373112124115317020452 0ustar www-datawww-data= Rake 10.0 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 10.0 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 --classic-namespace option is no longer supported. * Global constants are no longer supported. This includes Task, FileTask, FileCreationTask and RakeApp). 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 main object. Since main 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 Rake::DSL into your own classes and modules. * The deprecated syntax for task arguments (the one using :needs) has been removed. * The --reduce-compat flag has been removed (it's not needed anymore). * The deprecated rake/sys.rb library has been removed. * The deprecated rake/rdoctask.rb library has been removed. RDoc supplies its own rake task now. * The deprecated rake/gempackagetask.rb 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) Since Rake 10 includes the changes from the last version of Rake 9, we'll repeat the changes for version 0.9.3 here. === New Features * 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 * 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. == 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 rake-10.0.4/doc/release_notes/rake-0.9.4.rdoc0000644000004100000410000000563512124115317020412 0ustar www-datawww-data= Rake 0.9.4 Released Rake version 0.9.4 contains a number of bug fixes. == Changes === 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 (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 (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) == 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 alot of these changes. The following people either 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 rake-10.0.4/doc/release_notes/rake-0.8.4.rdoc0000644000004100000410000001177612124115317020414 0ustar www-datawww-data= Rake 0.8.4 Released Rake version 0.8.4 is a bug-fix release of rake. NOTE: The version of Rake that comes with Ruby 1.9 has diverged slightly from the core Rake code base. Rake 0.8.4 will work with Ruby 1.9, but is not a strict upgrade for the Rake that comes with Ruby 1.9. A (near) future release of Rake will unify those two codebases. == Letter Writing Campaign Thanks to Aaron Patterson (@tenderlove) and Eric Hodel (@drbrain) for their encouraging support in organizing a letter writing campaign to lobby for the "Warning Free" release of rake 0.8.4. A special callout goes to Jonathan D. Lord, Sr (Dr. Wingnut) whose postcard was the first to actually reach me. (see http://tenderlovemaking.com/2009/02/26/we-need-a-new-version-of-rake/ for details) == Changes === New Features / Enhancements in Version 0.8.4 * Case is preserved on rakefile names. (patch from James M. Lawrence/quix) * Improved Rakefile case insensitivity testing (patch from Luis Lavena). * Windows system dir search order is now: HOME, HOMEDRIVE + HOMEPATH, APPDATA, USERPROFILE (patch from Luis Lavena) * MingGW is now recognized as a windows platform. (patch from Luis Lavena) === Bug Fixes in Version 0.8.4 * Removed reference to manage_gem to fix the warning produced by the gem package task. * Fixed stray ARGV option problem that was interfering with Test::Unit::Runner. (patch from Pivotal Labs) === Infrastructure Improvements in Version 0.8.4 * Numerous fixes to the windows test suite (patch from Luis Lavena). * Improved Rakefile case insensitivity testing (patch from Luis Lavena). * Better support for windows paths in the test task (patch from Simon Chiang/bahuvrihi) == 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://rake.rubyforge.org/ Download:: http://rubyforge.org/project/showfiles.php?group_id=50 GitHub:: git://github.com/jimweirich/rake.git == Task Argument Examples Prior to version 0.8.0, rake was only able to handle command line arguments of the form NAME=VALUE that were passed into Rake via the ENV hash. Many folks had asked for some kind of simple command line arguments, perhaps using "--" to separate regular task names from argument values on the command line. The problem is that there was no easy way to associate positional arguments on the command line with different tasks. Suppose both tasks :a and :b expect a command line argument: does the first value go with :a? What if :b is run first? Should it then get the first command line argument. Rake 0.8.0 solves this problem by explicitly passing values directly to the tasks that need them. For example, if I had a release task that required a version number, I could say: rake release[0.8.4] And the string "0.8.4" will be passed to the :release task. Multiple arguments can be passed by separating them with a comma, for example: rake name[john,doe] Just a few words of caution. The rake task name and its arguments need to be a single command line argument to rake. This generally means no spaces. If spaces are needed, then the entire rake + argument string should be quoted. Something like this: rake "name[billy bob, smith]" (Quoting rules vary between operating systems and shells, so make sure you consult the proper docs for your OS/shell). === Tasks that Expect Parameters Parameters are only given to tasks that are setup to expect them. In order to handle named parameters, the task declaration syntax for tasks has been extended slightly. For example, a task that needs a first name and last name might be declared as: task :name, :first_name, :last_name The first argument is still the name of the task (:name in this case). The next to argumements are the names of the parameters expected by :name (:first_name and :last_name in the example). To access the values of the paramters, the block defining the task behaviour can now accept a second parameter: task :name, :first_name, :last_name do |t, args| puts "First name is #{args.first_name}" puts "Last name is #{args.last_name}" end The first argument of the block "t" is always bound to the current task object. The second argument "args" is an open-struct like object that allows access to the task arguments. Extra command line arguments to a task are ignored. Missing command line arguments are given the nil value. == Thanks As usual, it was input from users that drove a alot of these changes. The following people either contributed patches, made suggestions or made otherwise helpful comments. Thanks to ... * James M. Lawrence/quix * Luis Lavena * Pivotal Labs * Simon Chiang/bahuvrihi -- Jim Weirich rake-10.0.4/doc/release_notes/rake-0.4.15.rdoc0000644000004100000410000000212612124115317020457 0ustar www-datawww-data= Rake 0.4.15 Released == Changes Version 0.4.15 is a bug fix update for the Ruby 1.8.2 compatibility changes. This release includes: * Fixed a bug that prevented the TESTOPTS flag from working with the revised for 1.8.2 test task. * Updated the docs on --trace to indicate that it also enables a full backtrace on errors. * Several fixes for new warnings generated. == Mini-Roadmap I will continue to issue Rake updates in the 0.4.xx series as new Ruby-1.8.2 issues become manifest. Once the codebase stabilizes, I will release a 0.5.0 version incorporating all the changes. If you are not using Ruby-1.8.2 and wish to avoid version churn, I recommend staying with a release prior to Rake-0.4.14. == 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 Home Page:: http://rake.rubyforge.org/ Download:: http://rubyforge.org/project/showfiles.php?group_id=50 rake-10.0.4/doc/release_notes/rake-0.5.3.rdoc0000644000004100000410000000562212124115317020401 0ustar www-datawww-data= Rake 0.5.0 Released Although it has only been two weeks since the last release, we have enough updates to the Rake program to make it time for another release. == Changes Here are the changes for version 0.5.3 ... * FileLists have been extensively changed so that they mimic the behavior of real arrays even more closely. In particular, operations on FileLists that return a new collection (e.g. collect, reject) will now return a FileList rather than an array. In addition, several places where FileLists were not properly expanded before use have been fixed. * A method (+ext+) to simplify the handling of file extensions was added to String and to Array. * The 'testrb' script in test/unit tends to silently swallow syntax errors in test suites. Because of that, the default test loader is now a rake-provided script. You can still use 'testrb' by setting the loader flag in the test task to :testrb. (See the API documents for TestTask for all the loader flag values). * FileUtil methods (e.g. cp, mv, install) are now declared to be private. This will cut down on the interference with user defined methods of the same name. * Fixed the verbose flag in the TestTask so that the test code is controlled by the flag. Also shortened up some failure messages. (Thanks to Tobias Luetke for the suggestion). * Rules will now properly detect a task that can generate a source file. Previously rules would only consider source files that were already present. * Added an +import+ command that allows Rake to dynamically import dependendencies into a running Rake session. The +import+ command can run tasks to update the dependency file before loading them. Dependency files can be in rake or make format, allowing rake to work with tools designed to generate dependencies for make. == 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://rake.rubyforge.org/ Download:: http://rubyforge.org/project/showfiles.php?group_id=50 == Thanks As usual, it was input from users that drove a alot of these changes. Thanks to ... * Brian Gernhardt for the rules fix (especially for the patience to explain the problem to me until I got what he was talking about). * Stefan Lang for pointing out problems in the dark corners of the FileList implementation. * Alexey Verkhovsky pointing out the silently swallows syntax errors in tests. * Tobias Luetke for beautifying the test task output. * Sam Roberts for some of the ideas behind dependency loading. -- Jim Weirich rake-10.0.4/doc/command_line_usage.rdoc0000644000004100000410000001317212124115317017776 0ustar www-datawww-data= Rake Command Line Usage Rake is invoked from the command line using: % rake [options ...] [VAR=VALUE ...] [targets ...] Options are: [name=value] Set the environment variable name to value during the execution of the rake command. You can access the value by using ENV['name']. [--all (-A)] Used in combination with the -T and -D options, will force those options to show all the tasks, even the ones without comments. [--backtrace{=_output_} (-n)] Enable a full backtrace (i.e. like --trace, but without the task tracing details). The _output_ parameter is optional, but if specified it controls where the backtrace output is sent. If _output_ is stdout, then backtrace output is directed to stardard output. If _output_ is stderr, or if it is missing, then the backtrace output is sent to standard error. [--comments] Used in combination with the -W options to force the output to contain commented options only. This is the reverse of --all. [--describe _pattern_ (-D)] Describe the tasks (matching optional PATTERN), then exit. [--dry-run (-n)] Do a dry run. Print the tasks invoked and executed, but do not actually execute any of the actions. [--execute _code_ (-e)] Execute some Ruby code and exit. [--execute-print _code_ (-p)] Execute some Ruby code, print the result, and exit. [--execute-continue _code_ (-E)] Execute some Ruby code, then continue with normal task processing. [--help (-H)] Display some help text and exit. [--jobs _number_ (-j)] Specifies the number of active concurrent tasks used. The suggested value is equal to the number of CPUs. The concurrent tasks are used to execute the multitask prerequisites. Also see the -m option which turns all tasks into multitasks. Sample values: (no -j) : unlimited concurrent tasks (standard rake behavior) -j : 2 concurrent tasks (exact number may change) -j 16 : 16 concurrent tasks [--job-stats _level_] Display job statistics at the completion of the run. By default, this will display the requested number of active tasks (from the -j options) and the maximum number of tasks in play at any given time. If the optional _level_ is history, then a complete trace of task history will be displayed on standard output. [--libdir _directory_ (-I)] Add _directory_ to the list of directories searched for require. [--multitask (-m)] Treat all tasks as multitasks. ('make/drake' semantics) [--nosearch (-N)] Do not search for a Rakefile in parent directories. [--prereqs (-P)] Display a list of all tasks and their immediate prerequisites. [--quiet (-q)] Do not echo commands from FileUtils. [--rakefile _filename_ (-f)] Use _filename_ as the name of the rakefile. The default rakefile names are +rakefile+ and +Rakefile+ (with +rakefile+ taking precedence). If the rakefile is not found in the current directory, +rake+ will search parent directories for a match. The directory where the Rakefile is found will become the current directory for the actions executed in the Rakefile. [--rakelibdir _rakelibdir_ (-R)] Auto-import any .rake files in RAKELIBDIR. (default is 'rakelib') [--require _name_ (-r)] Require _name_ before executing the Rakefile. [--rules] Trace the rules resolution. [--silent (-s)] Like --quiet, but also suppresses the 'in directory' announcement. [--suppress-backtrace _pattern_ ] Line matching the regular expression _pattern_ will be removed from the backtrace output. Note that the --backtrace option is the full backtrace without these lines suppressed. [--system (-g)] Use the system wide (global) rakefiles. The project Rakefile is ignored. By default, the system wide rakefiles are used only if no project Rakefile is found. On Unix-like system, the system wide rake files are located in $HOME/.rake. On a windows system they are stored in $APPDATA/Rake. [--no-system (-G)] Use the project level Rakefile, ignoring the system-wide (global) rakefiles. [--tasks pattern (-T)] Display a list of the major tasks and their comments. Comments are defined using the "desc" command. If a pattern is given, then only tasks matching the pattern are displayed. [--trace{=_output_} (-t)] Turn on invoke/execute tracing. Also enable full backtrace on errors. The _output_ parameter is optional, but if specified it controls where the trace output is sent. If _output_ is stdout, then trace output is directed to stardard output. If _output_ is stderr, or if it is missing, then trace output is sent to standard error. [--verbose (-v)] Echo the Sys commands to standard output. [--version (-V)] Display the program version and exit. [--where pattern (-W)] Display tasks that match pattern and the file and line number where the task is defined. By default this option will display all tasks, not just the tasks that have descriptions. [--no-deprecation-warnings (-W)] Do not display the deprecation warnings. In addition, any command line option of the form VAR=VALUE will be added to the environment hash ENV and may be tested in the Rakefile. rake-10.0.4/README.rdoc0000644000004100000410000001333112124115317014352 0ustar www-datawww-data= RAKE -- Ruby Make This package contains Rake, a simple ruby build program with capabilities similar to make. Rake has the following features: * Rakefiles (rake's version of Makefiles) are completely defined in standard Ruby syntax. No XML files to edit. No quirky Makefile syntax to worry about (is that a tab or a space?) * Users can specify tasks with prerequisites. * Rake supports rule patterns to synthesize implicit tasks. * Flexible FileLists that act like arrays but know about manipulating file names and paths. * A library of prepackaged tasks to make building rakefiles easier. For example, tasks for building tarballs and publishing to FTP or SSH sites. (Formerly tasks for building RDoc and Gems were included in rake but they're now available in RDoc and RubyGems respectively.) * Supports parallel execution of tasks. == Installation === Gem Installation Download and install rake with the following. gem install rake == Usage === Simple Example First, you must write a "Rakefile" file which contains the build rules. Here's a simple example: task :default => [:test] task :test do ruby "test/unittest.rb" end This Rakefile has two tasks: * A task named "test", which - upon invocation - will run a unit test file in Ruby. * A task named "default". This task does nothing by itself, but it has exactly one dependency, namely the "test" task. Invoking the "default" task will cause Rake to invoke the "test" task as well. Running the "rake" command without any options will cause it to run the "default" task in the Rakefile: % ls Rakefile test/ % rake (in /home/some_user/Projects/rake) ruby test/unittest.rb ....unit test output here... Type "rake --help" for all available options. === More Information * For details on Rake's command-line invocation, read doc/command_line_usage.rdoc[https://github.com/jimweirich/rake/blob/master/doc/command_line_usage.rdoc] * For details on writing Rakefiles, see doc/rakefile.rdoc[https://github.com/jimweirich/rake/blob/master/doc/rakefile.rdoc]. * For the original announcement of Rake, see doc/rational.rdoc[https://github.com/jimweirich/rake/blob/master/doc/rational.rdoc]. * For a glossary of terms, see doc/glossary.rdoc[https://github.com/jimweirich/rake/blob/master/doc/glossary.rdoc]. == Development === Source Repository Rake is currently hosted at github. The github web page is http://github.com/jimweirich/rake. The public git clone URL is * git://github.com/jimweirich/rake.git === Running the Rake Test Suite If you wish to run the unit and functional tests that come with Rake: * Install the 'flexmock' gem * Install the 'session' gem in order to run the functional tests. * CD into the top project directory of rake. * Type one of the following: rake # If you have a version of rake installed ruby -Ilib bin/rake # If you do not have a version of rake installed. === Issues and Bug Reports Feature requests and bug reports can be made here * https://github.com/jimweirich/rake/issues Issues and bug reports can also be tracked here: * http://www.pivotaltracker.com/projects/28469 == Online Resources === Rake References * Rake Documentation Home: http://docs.rubyrake.org * Rake Project Page: http://rubyforge.org/projects/rake * Rake API Documents: http://rake.rubyforge.org * Rake Source Code Repo: http://github.com/jimweirich/rake * Rake Git Repo Clone URL: git://github.com/jimweirich/rake.git * Rake Bug Reports: https://github.com/jimweirich/rake/issues * Rake Continuous Build Server: https://travis-ci.org/#!/jimweirich/rake === Presentations and Articles about Rake * Jim Weirich's 2003 RubyConf presentation: http://onestepback.org/articles/buildingwithrake/ * Martin Fowler's article on Rake: http://martinfowler.com/articles/rake.html == Other Make Reinvisionings ... Rake is a late entry in the make replacement field. Here are links to other projects with similar (and not so similar) goals. * http://directory.fsf.org/bras.html -- Bras, one of earliest implementations of "make in a scripting language". * http://www.a-a-p.org -- Make in Python * http://www.aromatic.com/tools/jam.txt -- JAM, Java Automated Make * http://ant.apache.org -- The Ant project * http://ppt.perl.org/commands/make/index.html -- Make from the Perl Power Tools implementation. * http://search.cpan.org/search?query=PerlBuildSystem -- The Perl Build System * http://make.rubyforge.org -- Rant, another Ruby make tool. == Credits [Ryan Dlugosz] For the initial conversation that sparked Rake. [nobu.nokada@softhome.net] For the initial patch for rule support. [Tilman Sauerbeck ] For the recursive rule patch. [Eric Hodel] For aid in maintaining rake. == License Rake is available under an MIT-style license. :include: MIT-LICENSE == Support The Rake homepage is http://rake.rubyforge.org. You can find the Rake RubyForge page at http://rubyforge.org/projects/rake. Feel free to submit commits or feature requests. If you send a patch, remember to update the corresponding unit tests. In fact, I prefer new feature to be submitted in the form of new unit tests. For other information, feel free to ask on the ruby-talk mailing list (which is mirrored to comp.lang.ruby) or contact jim dot weirich at gmail.com. --- = Other stuff Author:: Jim Weirich Requires:: Ruby 1.8.7 or later License:: Copyright 2003-2013 by Jim Weirich. Released under an MIT-style license. See the MIT-LICENSE file included in the distribution. == Warranty This software is provided "as is" and without any express or implied warranties, including, without limitation, the implied warranties of merchantibility and fitness for a particular purpose. rake-10.0.4/Rakefile0000644000004100000410000002260512124115317014215 0ustar www-datawww-data# Rakefile for rake -*- ruby -*- # Copyright 2003, 2004, 2005 by Jim Weirich (jim@weirichhouse.org) # All rights reserved. # This file may be distributed under an MIT style license. See # MIT-LICENSE for details. require 'rbconfig' require 'rubygems' system_rake = File.join RbConfig::CONFIG['rubylibdir'], 'rake.rb' # Use our rake, not the installed rake from system if $".include? system_rake or $".grep(/rake\/name_space\.rb$/).empty? then exec Gem.ruby, '-Ilib', 'bin/rake', *ARGV end require 'rubygems/package_task' require 'rake/clean' require 'rake/testtask' begin gem 'rdoc' require 'rdoc/task' rescue Gem::LoadError end CLEAN.include('**/*.o', '*.dot', '**/*.rbc') CLOBBER.include('doc/example/main') CLOBBER.include('TAGS') CLOBBER.include('coverage', 'rcov_aggregate') # Prevent OS X from including extended attribute junk in the tar output ENV['COPY_EXTENDED_ATTRIBUTES_DISABLE'] = 'true' def announce(msg='') STDERR.puts msg end # Determine the current version of the software if `ruby -Ilib ./bin/rake --version` =~ /rake, version ([0-9a-z.]+)$/ CURRENT_VERSION = $1 else CURRENT_VERSION = "0.0.0" end $package_version = CURRENT_VERSION SRC_RB = FileList['lib/**/*.rb'] # The default task is run if rake is given no explicit arguments. desc "Default Task" task :default => :test # Test Tasks --------------------------------------------------------- Rake::TestTask.new do |t| files = FileList['test/helper.rb', 'test/test_*.rb'] t.loader = :rake t.test_files = files t.libs << "." t.warning = true end begin require 'rcov/rcovtask' IGNORE_COVERAGE_IN = FileList[ 'lib/rake/rdoctask.rb', 'lib/rake/testtask.rb', 'lib/rake/packagetask.rb', 'lib/rake/clean.rb', ] unless File::ALT_SEPARATOR IGNORE_COVERAGE_IN.include( 'lib/rake/alt_system.rb', 'lib/rake/win32.rb') end Rcov::RcovTask.new do |t| t.libs << "test" t.rcov_opts = [ '-xRakefile', '-xrakefile', '-xpublish.rf', '-xlib/rake/contrib', '-x/Library', '-x.rvm', '--text-report', '--sort coverage' ] + FileList['rakelib/*.rake'].pathmap("-x%p") + IGNORE_COVERAGE_IN.map { |fn| "-x#{fn}" } t.test_files = FileList[ 'test/lib/*_test.rb', 'test/contrib/*_test.rb', 'test/functional/*_test.rb' ] t.output_dir = 'coverage' t.verbose = true end rescue LoadError task :rcov do puts "RCov is not available" end end # CVS Tasks ---------------------------------------------------------- # Install rake using the standard install.rb script. desc "Install the application" task :install do ruby "install.rb" end # Create a task to build the RDOC documentation tree. BASE_RDOC_OPTIONS = [ '--line-numbers', '--show-hash', '--main', 'README.rdoc', '--title', 'Rake -- Ruby Make' ] if defined?(RDoc::Task) then RDoc::Task.new do |rdoc| rdoc.rdoc_dir = 'html' rdoc.title = "Rake -- Ruby Make" rdoc.options = BASE_RDOC_OPTIONS.dup rdoc.rdoc_files.include('README.rdoc', 'MIT-LICENSE', 'TODO', 'CHANGES') rdoc.rdoc_files.include('lib/**/*.rb', 'doc/**/*.rdoc') rdoc.rdoc_files.exclude(/\bcontrib\b/) end else warn "RDoc 2.4.2+ is required to build documentation" end # ==================================================================== # Create a task that will package the Rake software into distributable # tar, zip and gem files. PKG_FILES = FileList[ '.gemtest', 'install.rb', 'CHANGES', 'MIT-LICENSE', 'README.rdoc', 'Rakefile', 'TODO', 'bin/rake', 'lib/**/*.rb', 'test/**/*.rb', 'doc/**/*' ] PKG_FILES.exclude('doc/example/*.o') PKG_FILES.exclude('TAGS') PKG_FILES.exclude(%r{doc/example/main$}) if ! defined?(Gem) puts "Package Target requires RubyGems" else SPEC = Gem::Specification.new do |s| s.name = 'rake' s.version = $package_version s.summary = "Ruby based make-like utility." s.license = "MIT" s.description = <<-EOF.delete "\n" Rake is a Make-like program implemented in Ruby. Tasks and dependencies are specified in standard Ruby syntax. EOF s.required_ruby_version = '>= 1.8.6' s.required_rubygems_version = '>= 1.3.2' s.add_development_dependency 'minitest', '~> 2.1' s.files = PKG_FILES.to_a s.executables = ["rake"] s.extra_rdoc_files = FileList[ 'README.rdoc', 'MIT-LICENSE', 'TODO', 'CHANGES', 'doc/**/*.rdoc' ] s.rdoc_options = BASE_RDOC_OPTIONS s.author = "Jim Weirich" s.email = "jim@weirichhouse.org" s.homepage = "http://rake.rubyforge.org" s.rubyforge_project = "rake" end Gem::PackageTask.new(SPEC) do |pkg| pkg.need_zip = true pkg.need_tar = true end file "rake.gemspec" => ["Rakefile", "lib/rake.rb"] do |t| require 'yaml' open(t.name, "w") { |f| f.puts SPEC.to_yaml } end desc "Create a stand-alone gemspec" task :gemspec => "rake.gemspec" end # Misc tasks ========================================================= def count_lines(filename) lines = 0 codelines = 0 open(filename) { |f| f.each do |line| lines += 1 next if line =~ /^\s*$/ next if line =~ /^\s*#/ codelines += 1 end } [lines, codelines] end def show_line(msg, lines, loc) printf "%6s %6s %s\n", lines.to_s, loc.to_s, msg end desc "Count lines in the main rake file" task :lines do total_lines = 0 total_code = 0 show_line("File Name", "LINES", "LOC") SRC_RB.each do |fn| lines, codelines = count_lines(fn) show_line(fn, lines, codelines) total_lines += lines total_code += codelines end show_line("TOTAL", total_lines, total_code) end # Define an optional publish target in an external file. If the # publish.rf file is not found, the publish targets won't be defined. load "publish.rf" if File.exist? "publish.rf" # Support Tasks ------------------------------------------------------ RUBY_FILES = FileList['**/*.rb'].exclude('pkg') desc "Look for TODO and FIXME tags in the code" task :todo do RUBY_FILES.egrep(/#.*(FIXME|TODO|TBD)/) end desc "List all ruby files" task :rubyfiles do puts RUBY_FILES puts FileList['bin/*'].exclude('bin/*.rb') end task :rf => :rubyfiles # -------------------------------------------------------------------- # Creating a release def plugin(plugin_name) require "rake/plugins/#{plugin_name}" end task :noop #plugin "release_manager" desc "Make a new release" task :release, [:rel, :reuse, :reltest] => [ :prerelease, :clobber, :test, :update_version, :package, :tag ] do announce announce "**************************************************************" announce "* Release #{$package_version} Complete." announce "* Packages ready to upload." announce "**************************************************************" announce end # Validate that everything is ready to go for a release. task :prerelease, :rel, :reuse, :reltest do |t, args| $package_version = args.rel announce announce "**************************************************************" announce "* Making RubyGem Release #{$package_version}" announce "* (current version #{CURRENT_VERSION})" announce "**************************************************************" announce # Is a release number supplied? unless args.rel fail "Usage: rake release[X.Y.Z] [REUSE=tag_suffix]" end # Is the release different than the current release. # (or is REUSE set?) if $package_version == CURRENT_VERSION && ! args.reuse fail "Current version is #{$package_version}, must specify REUSE=tag_suffix to reuse version" end # Are all source files checked in? if args.reltest announce "Release Task Testing, skipping checked-in file test" else announce "Checking for unchecked-in files..." data = `svn st` unless data =~ /^$/ abort "svn status is not clean ... do you have unchecked-in files?" end announce "No outstanding checkins found ... OK" end end task :update_version, [:rel, :reuse, :reltest] => [:prerelease] do |t, args| if args.rel == CURRENT_VERSION announce "No version change ... skipping version update" else announce "Updating Rake version to #{args.rel}" open("lib/rake.rb") do |rakein| open("lib/rake.rb.new", "w") do |rakeout| rakein.each do |line| if line =~ /^RAKEVERSION\s*=\s*/ rakeout.puts "RAKEVERSION = '#{args.rel}'" else rakeout.puts line end end end end mv "lib/rake.rb.new", "lib/rake.rb" if args.reltest announce "Release Task Testing, skipping commiting of new version" else sh %{svn commit -m "Updated to version #{args.rel}" lib/rake.rb} # " end end end desc "Tag all the CVS files with the latest release number (REL=x.y.z)" task :tag, [:rel, :reuse, :reltest] => [:prerelease] do |t, args| reltag = "REL_#{args.rel.gsub(/\./, '_')}" reltag << args.reuse.gsub(/\./, '_') if args.reuse announce "Tagging Repository with [#{reltag}]" if args.reltest announce "Release Task Testing, skipping CVS tagging" else sh %{svn copy svn+ssh://rubyforge.org/var/svn/rake/trunk svn+ssh://rubyforge.org/var/svn/rake/tags/#{reltag} -m 'Commiting release #{reltag}'} ###' end end # Require experimental XForge/Metaproject support. load 'xforge.rf' if File.exist?('xforge.rf') desc "Where is the current directory. This task displays\nthe current rake directory" task :where_am_i do puts Rake.original_dir end task :failure => :really_fail task :really_fail do fail "oops" end rake-10.0.4/TODO0000644000004100000410000000140412124115317013232 0ustar www-datawww-data= Rake Project -- To Do List Send suggestions for this list to mailto:jim@weirichhouse.org or on the rake-devel@rubyforge.org mailing list. === To Do * Need a nice API for accessing tasks in namespaces, namespaces in an app, etc. * Provide a way to disable -w warning mode. * Define a set of default rules that work in the absence of any Rakefile * What about cyclic dependencies? * Java support utilities * Installation support utilities * Check out installpkg.rb * Autogenerate Dependencies * Rules should apply to existing tasks if no actions are defined. * How to create multiple package tasks without task name collision? * Trap "ln -s" commands that fail and use "cp" instead (SMB mounted drives have problems with "ln -s". (moved DONE list to CHANGES file) rake-10.0.4/.gemtest0000644000004100000410000000000012124115317014202 0ustar www-datawww-datarake-10.0.4/bin/0000755000004100000410000000000012124115317013313 5ustar www-datawww-datarake-10.0.4/bin/rake0000755000004100000410000000233412124115317014165 0ustar www-datawww-data#!/usr/bin/env ruby #-- # Copyright (c) 2003, 2004, 2005, 2006, 2007 Jim Weirich # # 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. #++ begin require 'rubygems' gem 'rake' rescue LoadError end require 'rake' Rake.application.run rake-10.0.4/checksums.yaml.gz0000444000004100000410000000041512124115317016031 0ustar www-datawww-data‹•PQe;r0{ŸÂp!.]úœ€ŸR¥É¸Êé#»5ovy·Ûíòõù1Þ/×ëOß½üîoßïרRs60ÂDžDËÙ o‰ÊKÛ}ŸÜ3s÷ßgŽT;yw‹ñ°‘s åÒ©8±[K‘š×ƒÊ_¸J¦ÆqŽYÆôB´ ³X¤Ç‚ámœèŽóL’•`ëÎ:Zœ¦+‡Æ [ÆCž-EÂV/YÀ³}ùİ‚ظ¡æË? d£–Tœ› Üꬽ§É1:(§° UŠ<…IÌÌ>Ec1Y¸ H9V¬-fB$çM§=¢4Ðm¦CÑ)–ë¤ÝǺü5L(T¢rake-10.0.4/metadata.yml0000644000004100000410000001547212124115317015057 0ustar www-datawww-data--- !ruby/object:Gem::Specification name: rake version: !ruby/object:Gem::Version version: 10.0.4 platform: ruby authors: - Jim Weirich autorequire: bindir: bin cert_chain: [] date: 2013-03-25 00:00:00.000000000 Z dependencies: - !ruby/object:Gem::Dependency name: minitest requirement: !ruby/object:Gem::Requirement requirements: - - ~> - !ruby/object:Gem::Version version: '2.1' type: :development prerelease: false version_requirements: !ruby/object:Gem::Requirement requirements: - - ~> - !ruby/object:Gem::Version version: '2.1' description: Rake is a Make-like program implemented in Ruby. Tasks and dependencies arespecified in standard Ruby syntax. email: jim@weirichhouse.org executables: - rake extensions: [] extra_rdoc_files: - README.rdoc - MIT-LICENSE - TODO - CHANGES - doc/command_line_usage.rdoc - doc/glossary.rdoc - doc/proto_rake.rdoc - doc/rakefile.rdoc - doc/rational.rdoc - doc/release_notes/rake-0.4.14.rdoc - doc/release_notes/rake-0.4.15.rdoc - doc/release_notes/rake-0.5.0.rdoc - doc/release_notes/rake-0.5.3.rdoc - doc/release_notes/rake-0.5.4.rdoc - doc/release_notes/rake-0.6.0.rdoc - doc/release_notes/rake-0.7.0.rdoc - doc/release_notes/rake-0.7.1.rdoc - doc/release_notes/rake-0.7.2.rdoc - doc/release_notes/rake-0.7.3.rdoc - doc/release_notes/rake-0.8.0.rdoc - doc/release_notes/rake-0.8.2.rdoc - doc/release_notes/rake-0.8.3.rdoc - doc/release_notes/rake-0.8.4.rdoc - doc/release_notes/rake-0.8.5.rdoc - doc/release_notes/rake-0.8.6.rdoc - doc/release_notes/rake-0.8.7.rdoc - doc/release_notes/rake-0.9.0.rdoc - doc/release_notes/rake-0.9.1.rdoc - doc/release_notes/rake-0.9.2.2.rdoc - doc/release_notes/rake-0.9.2.rdoc - doc/release_notes/rake-0.9.3.rdoc - doc/release_notes/rake-0.9.4.rdoc - doc/release_notes/rake-0.9.5.rdoc - doc/release_notes/rake-0.9.6.rdoc - doc/release_notes/rake-10.0.0.rdoc - doc/release_notes/rake-10.0.1.rdoc - doc/release_notes/rake-10.0.2.rdoc - doc/release_notes/rake-10.0.3.rdoc files: - .gemtest - install.rb - CHANGES - MIT-LICENSE - README.rdoc - Rakefile - TODO - bin/rake - lib/rake.rb - lib/rake/alt_system.rb - lib/rake/application.rb - lib/rake/backtrace.rb - lib/rake/clean.rb - lib/rake/cloneable.rb - lib/rake/contrib/compositepublisher.rb - lib/rake/contrib/ftptools.rb - lib/rake/contrib/publisher.rb - lib/rake/contrib/rubyforgepublisher.rb - lib/rake/contrib/sshpublisher.rb - lib/rake/contrib/sys.rb - lib/rake/default_loader.rb - lib/rake/dsl_definition.rb - lib/rake/early_time.rb - lib/rake/ext/core.rb - lib/rake/ext/module.rb - lib/rake/ext/string.rb - lib/rake/ext/time.rb - lib/rake/file_creation_task.rb - lib/rake/file_list.rb - lib/rake/file_task.rb - lib/rake/file_utils.rb - lib/rake/file_utils_ext.rb - lib/rake/gempackagetask.rb - lib/rake/invocation_chain.rb - lib/rake/invocation_exception_mixin.rb - lib/rake/loaders/makefile.rb - lib/rake/multi_task.rb - lib/rake/name_space.rb - lib/rake/packagetask.rb - lib/rake/pathmap.rb - lib/rake/phony.rb - lib/rake/private_reader.rb - lib/rake/promise.rb - lib/rake/pseudo_status.rb - lib/rake/rake_module.rb - lib/rake/rake_test_loader.rb - lib/rake/rdoctask.rb - lib/rake/ruby182_test_unit_fix.rb - lib/rake/rule_recursion_overflow_error.rb - lib/rake/runtest.rb - lib/rake/task.rb - lib/rake/task_argument_error.rb - lib/rake/task_arguments.rb - lib/rake/task_manager.rb - lib/rake/tasklib.rb - lib/rake/testtask.rb - lib/rake/thread_history_display.rb - lib/rake/thread_pool.rb - lib/rake/trace_output.rb - lib/rake/version.rb - lib/rake/win32.rb - test/file_creation.rb - test/helper.rb - test/test_private_reader.rb - test/test_rake.rb - test/test_rake_application.rb - test/test_rake_application_options.rb - test/test_rake_backtrace.rb - test/test_rake_clean.rb - test/test_rake_definitions.rb - test/test_rake_directory_task.rb - test/test_rake_dsl.rb - test/test_rake_early_time.rb - test/test_rake_extension.rb - test/test_rake_file_creation_task.rb - test/test_rake_file_list.rb - test/test_rake_file_list_path_map.rb - test/test_rake_file_task.rb - test/test_rake_file_utils.rb - test/test_rake_ftp_file.rb - test/test_rake_functional.rb - test/test_rake_invocation_chain.rb - test/test_rake_makefile_loader.rb - test/test_rake_multi_task.rb - test/test_rake_name_space.rb - test/test_rake_package_task.rb - test/test_rake_path_map.rb - test/test_rake_path_map_explode.rb - test/test_rake_path_map_partial.rb - test/test_rake_pseudo_status.rb - test/test_rake_rake_test_loader.rb - test/test_rake_reduce_compat.rb - test/test_rake_require.rb - test/test_rake_rules.rb - test/test_rake_task.rb - test/test_rake_task_argument_parsing.rb - test/test_rake_task_arguments.rb - test/test_rake_task_lib.rb - test/test_rake_task_manager.rb - test/test_rake_task_manager_argument_resolution.rb - test/test_rake_task_with_arguments.rb - test/test_rake_test_task.rb - test/test_rake_thread_pool.rb - test/test_rake_top_level_functions.rb - test/test_rake_win32.rb - test/test_thread_history_display.rb - test/test_trace_output.rb - doc/command_line_usage.rdoc - doc/example/Rakefile1 - doc/example/Rakefile2 - doc/example/a.c - doc/example/b.c - doc/example/main.c - doc/glossary.rdoc - doc/jamis.rb - doc/proto_rake.rdoc - doc/rake.1.gz - doc/rakefile.rdoc - doc/rational.rdoc - doc/release_notes/rake-0.4.14.rdoc - doc/release_notes/rake-0.4.15.rdoc - doc/release_notes/rake-0.5.0.rdoc - doc/release_notes/rake-0.5.3.rdoc - doc/release_notes/rake-0.5.4.rdoc - doc/release_notes/rake-0.6.0.rdoc - doc/release_notes/rake-0.7.0.rdoc - doc/release_notes/rake-0.7.1.rdoc - doc/release_notes/rake-0.7.2.rdoc - doc/release_notes/rake-0.7.3.rdoc - doc/release_notes/rake-0.8.0.rdoc - doc/release_notes/rake-0.8.2.rdoc - doc/release_notes/rake-0.8.3.rdoc - doc/release_notes/rake-0.8.4.rdoc - doc/release_notes/rake-0.8.5.rdoc - doc/release_notes/rake-0.8.6.rdoc - doc/release_notes/rake-0.8.7.rdoc - doc/release_notes/rake-0.9.0.rdoc - doc/release_notes/rake-0.9.1.rdoc - doc/release_notes/rake-0.9.2.2.rdoc - doc/release_notes/rake-0.9.2.rdoc - doc/release_notes/rake-0.9.3.rdoc - doc/release_notes/rake-0.9.4.rdoc - doc/release_notes/rake-0.9.5.rdoc - doc/release_notes/rake-0.9.6.rdoc - doc/release_notes/rake-10.0.0.rdoc - doc/release_notes/rake-10.0.1.rdoc - doc/release_notes/rake-10.0.2.rdoc - doc/release_notes/rake-10.0.3.rdoc homepage: http://rake.rubyforge.org licenses: - MIT metadata: {} post_install_message: rdoc_options: - --line-numbers - --show-hash - --main - README.rdoc - --title - Rake -- Ruby Make require_paths: - lib required_ruby_version: !ruby/object:Gem::Requirement requirements: - - '>=' - !ruby/object:Gem::Version version: 1.8.6 required_rubygems_version: !ruby/object:Gem::Requirement requirements: - - '>=' - !ruby/object:Gem::Version version: 1.3.2 requirements: [] rubyforge_project: rake rubygems_version: 2.0.3 signing_key: specification_version: 4 summary: Ruby based make-like utility. test_files: [] rake-10.0.4/install.rb0000644000004100000410000000416212124115317014541 0ustar www-datawww-datarequire 'rbconfig' require 'find' require 'fileutils' include RbConfig $ruby = CONFIG['ruby_install_name'] ## # Install a binary file. We patch in on the way through to # insert a #! line. If this is a Unix install, we name # the command (for example) 'rake' and let the shebang line # handle running it. Under windows, we add a '.rb' extension # and let file associations to their stuff # def installBIN(from, opfile) tmp_dir = nil for t in [".", "/tmp", "c:/temp", $bindir] stat = File.stat(t) rescue next if stat.directory? and stat.writable? tmp_dir = t break end end fail "Cannot find a temporary directory" unless tmp_dir tmp_file = File.join(tmp_dir, "_tmp") File.open(from) do |ip| File.open(tmp_file, "w") do |op| ruby = File.join($realbindir, $ruby) op.puts "#!#{ruby} -w" op.write ip.read end end opfile += ".rb" if CONFIG["target_os"] =~ /mswin/i FileUtils.install(tmp_file, File.join($bindir, opfile), {:mode => 0755, :verbose => true}) File.unlink(tmp_file) end $sitedir = CONFIG["sitelibdir"] unless $sitedir version = CONFIG["MAJOR"]+"."+CONFIG["MINOR"] $libdir = File.join(CONFIG["libdir"], "ruby", version) $sitedir = $:.find {|x| x =~ /site_ruby/} if !$sitedir $sitedir = File.join($libdir, "site_ruby") elsif $sitedir !~ Regexp.quote(version) $sitedir = File.join($sitedir, version) end end $bindir = CONFIG["bindir"] $realbindir = $bindir bindir = CONFIG["bindir"] if (destdir = ENV['DESTDIR']) $bindir = destdir + $bindir $sitedir = destdir + $sitedir FileUtils.mkdir_p($bindir) FileUtils.mkdir_p($sitedir) end rake_dest = File.join($sitedir, "rake") FileUtils.mkdir_p(rake_dest, {:verbose => true}) File.chmod(0755, rake_dest) # The library files files = Dir.chdir('lib') { Dir['**/*.rb'].sort } for fn in files fn_dir = File.dirname(fn) target_dir = File.join($sitedir, fn_dir) if ! File.exist?(target_dir) FileUtils.mkdir_p(target_dir) end FileUtils.install(File.join('lib', fn), File.join($sitedir, fn), {:mode => 0644, :verbose => true}) end # and the executable installBIN("bin/rake", "rake") rake-10.0.4/CHANGES0000644000004100000410000004340612124115317013545 0ustar www-datawww-data= Rake Changelog NOTE: Refer to the individual release documents (in the doc/release_notes directory) for changes after in version 0.9.4 and later. == Master (for 0.9.3) * The rake test loader now removes arguments it has processed. Issue #51 * Rake::TaskArguments now responds to #values_at * RakeFileUtils.verbose_flag = nil silences output the same as 0.8.7 * Rake tests are now directory-independent * Rake tests are no longer require flexmock * Commands constant is no longer polluting top level namespace. * Show only the interesting portion of the backtrace by default (James M. Lawrence). * Added --reduce-compat optiont to remove backward compatible DSL hacks (James M. Lawrence). * lib/rake/file_list.rb (Rake::FileList#egrep): there is no need to open files in binary mode. (NAKAMURA Usaku) == Version 0.9.2 * Unknown == Version 0.9.1 * Added deprecation warnings to the Rake DSL methods. == Version 0.9.0 * *Incompatible* *change*: Rake DSL commands ('task', 'file', etc.) are no longer private methods in Object. If you need to call 'task :xzy' inside your class, include Rake::DSL into the class. The DSL is still available at the top level scope (via the top level object which extends Rake::DSL). * Rake now warns when the deprecated :needs syntax used. * Rake history is now UTF-8 encoded. * Rake now uses case-insensitive comparisons to find the Rakefile on Windows. Based on patch by Roger Pack. * Rake now requires (instead of loads) files in the test task. Patch by Cezary Baginski. * Fixed typos. Patches by Sean Scot August Moon and R.T. Lechow. * Rake now prints the Rakefile directory only when it's different from the current directory. Patch by Alex Chaffee. * Improved rakefile_location discovery on Windows. Patch by James Tucker. * Rake now recognizes "Windows Server" as a windows system. Patch by Matthias Lüdtke * Rake::RDocTask is deprecated. Use RDoc::Task from RDoc 2.4.2+ (require 'rdoc/task') * Rake::GemPackageTask is deprecated. Use Gem::PackageTask (require 'rubygems/package_task') * Rake now outputs various messages to $stderr instead of $stdout. * Rake no longer emits warnings for Config. Patch by Santiago Pastorino. * Split rake.rb into individual files. * Support for the --where (-W) flag for showing where a task is defined. * Fixed quoting in test task. (http://onestepback.org/redmine/issues/show/44, http://www.pivotaltracker.com/story/show/1223138) * Fixed the silent option parsing problem. (http://onestepback.org/redmine/issues/show/47) * Fixed :verbose=>false flag on sh and ruby commands. * Rake command line options may be given by default in a RAKEOPT environment variable. * Errors in Rake will now display the task invocation chain in effect at the time of the error. * Accepted change by warnickr to not expand test patterns in shell (allowing more files in the test suite). * Fixed that file tasks did not perform prereq lookups in scope (Redmine #57). == Version 0.8.7 * Fixed EXEEXT for JRuby on windows. == Version 0.8.6 * Minor fixes to the RDoc generation (removed dependency on darkfish and removed inline source option). == PreVersion 0.8.6 * Now allow # comments to comment a task definition. == Version 0.8.5 * Better support for the system command on Windows. == Version 0.8.4 * Preserve case when locating rakefiles (patch from James M. Lawrence/quix) * Better support for windows paths in the test task (patch from Simon Chiang/bahuvrihi) * Windows system dir search order is now: HOME, HOMEDRIVE + HOMEPATH, APPDATA, USERPROFILE (patch from Luis Lavena) * MingGW is now recognized as a windows platform. (patch from Luis Lavena) * Numerous fixes to the windows test suite (patch from Luis Lavena). * Improved Rakefile case insensitivity testing (patch from Luis Lavena). * Fixed stray ARGV option problem that was interfering with Test::Unit::Runner. * Fixed default verbose mode (was accidently changed to false). * Removed reference to manage_gem to fix the warning produced by the gem package task. == Version 0.8.3 * Enhanced the system directory detection in windows. We now check HOMEDRIVE/HOMEPATH and USERPROFILE if APPDATA isn't found. (Patch supplied by James Tucker). Rake no long aborts if it can't find the directory. * Added fix to handle ruby installations in directories with spaces in their name. == Version 0.8.2 * Fixed bug in package task so that it will include the subdir directory in the package for testing. (Bug found by Adam Majer) * Added ENV var to rakefile to prevent OS X from including extended attribute junk in a tar file. (Bug found by Adam Majer) * Fixed filename dependency order bug in test_inspect_pending and test_to_s_pending. (Bug found by Adam Majer) * Fixed check for file utils options to make them immune to the symbol/string differences. (Patch supplied by Edwin Pratomo) * Fixed bug with rules involving multiple source (Patch supplied by Emanuel Indermühle) * Switched from getoptlong to optparse (patches supplied by Edwin Pratomo) * The -T option will now attempt to dynamically sense the size of the terminal. RAKE_COLUMNS will override any dynamic sensing. * FileList#clone and FileList#dup have better sematics w.r.t. taint and freeze. * Added ability clear prerequisites, and/or actions from an existing task. * Added the ability to reenable a task to be invoked a second time. * Changed RDoc test task to have no default template. This makes it easier for the tempate to pick up the template from the environment. * Changed from using Mutex to Monitor. Evidently Mutex causes thread join errors when Ruby is compiled with -disable-pthreads. (Patch supplied by Ittay Dror) * Fixed bug in makefile parser that had problems with extra spaces in file task names. (Patch supplied by Ittay Dror) * Added a performance patch for reading large makefile dependency files. (Patch supplied by Ittay Dror) * Default values for task arguments can easily be specified with the :with_defaults method. (Idea for default argument merging supplied by (Adam Q. Salter) * The -T output will only self-truncate if the output is a tty. However, if RAKE_COLUMNS is explicitly set, it will be honored in any case. (Patch provided by Gavin Stark). * Numerous fixes for running under windows. A big thanks to Bheeshmar Redheendran for spending a good part of the afternoon at the Lonestar Ruby Conference to help me work out these issues. == Version 0.8.1 * Removed requires on parsedate.rb (in Ftptools) * Removed ftools from rake.rb. Made it options in sys.rb == Version 0.8.0 * Added task parameters (e.g. "rake build[version7]") * Made task parameters passable to prerequisites. * Comments are limited to 80 columns or so (suggested by Jamis Buck). * Added -D to display full comments (suggested by Jamis Buck). * The rake program will set the status value used in any explicit exit(n) calls. (patch provided by Stephen Touset) * Fixed error in functional tests that were not including session (and silently skipping the functionl tests. * Removed --usage and make -h the same as -H. * Make a prettier inspect for tasks. == Version 0.7.3 * Added existing and existing! methods to FileList * FileLists now claim to be Arrays (via is_a?) to get better support from the FileUtil module. * Added init and top_level for custom rake applications. == Version 0.7.2 * Error messages are now send to stderr rather than stdout (from Payton Quackenbush). * Better error handling on invalid command line arguments (from Payton Quackenbush). * Added rcov task and updated unit testing for better code coverage. * Fixed some bugs where the application object was going to the global appliation instead of using its own data. * Added square and curly bracket patterns to FileList#include (Tilman Sauerbeck). * Added plain filename support to rule dependents (suggested by Nobu Nakada). * Added pathmap support to rule dependents. * Added a 'tasks' method to a namespace to get a list of tasks associated with the namespace. * Fixed the method name leak from FileUtils (bug found by Glenn Vanderburg). * Added rake_extension to handle detection of extension collisions. * Added test for noop, bad_option and verbose flags to sh command. * Removed dependency on internal fu_xxx functions from FileUtils. * Added a 'shame' task to the Rakefile. * Added tar_command and zip_command options to the Package task. * Added a description to the gem task in GemPackageTask. * Fixed a bug when rules have multiple prerequisites (patch by Joel VanderWerf) * Added a protected 'require "rubygems"' to test/test_application to unbreak cruisecontrol.rb. * Added the handful of RakeFileUtils to the private method as well. * Added block based exclusion. * The clean task will no longer delete 'core' if it is a directory. * Removed rake_dup. Now we just simply rescue a bad dup. * Refactored the FileList reject logic to remove duplication. * Removed if __FILE__ at the end of the rake.rb file. == Version 0.7.1 * Added optional filter parameter to the --tasks command line option. * Added flatten to allow rule transform procs to return lists of prereqs (Joel VanderWerf provided patch). * Added pathmap to String and FileList. * The -r option will now load .rake files (but a straight require doesn't yet). NOTE: This is experimental ... it may be discontinued. * The -f option without a value will disable the search for a Rakefile. The assumption is that the -r files are adequate. * Fixed the safe_ln function to fall back to cp in more error scenarios. == Version 0.7.0 * Added Rake.original_dir to return the original starting directory of the rake application. * Added safe_ln support for openAFS (from Ludvig Omholt). * Added --trace reminder on short exception messages (David Heinemeier Hansson suggestion). * Added multitask declaration that executes prerequisites in parallel. (Doug Young providied an initial implementation). * Fixed missing_const hack to be compatible with Rails. (Jamis Buck supplied test case). * Made the RDoc task default to internal (in-process) RDoc formatting. The old behavior is still available by setting the +external+ flag to true. * Rakefiles are now loaded with the expanded path to prevent accidental polution from the Ruby load path. * The +namespace+ command now returns a NameSpace object that can be used to lookup tasks defined in that namespace. This allows for better anonymous namespace behavior. * Task objects my now be used in prerequisite lists directly. == Version 0.6.1 * Rebuilt 0.6.0 gem without signing. == Version 0.6.0 * Fixed file creation bug in the unit tests (caused infinite loop on windows). * Fixed bug where session based functional tests were run under windows. * Fixed bug in directory tasks so that updating a directory will not retrigger file tasks depending on the directory (see FileCreationTask and EarlyTime). * Added egrep to FileList * ruby command now runs same ruby version as rake. * Added investigation to task object. (suggested by Martin Fowler) * Added ruby_opts to the test task to allow arbitrary ruby options to be passed to the test script. (Greg Fast) * Fixed the test loader to ignore options. (Greg Fast) * Moved Task, FileTask, FileCreationTask and RakeApp into the Rake module namespace. Old style namespace behavior can be invoked via the --classic-namespace option. (requested by Kelly Felkins). * GemTask is now sensitive to the gem platform (Masao Mutoh). * A non-existing file prerequisite will no longer cause an exception (Philipp Neubeck). * Multiple prerequisites on Rake rules now allowed (initial patch supplied by Stuart Jansen). == Version 0.5.4 * Added double quotes to the test runner. * Added .svn to default ignore list. * Updated FileList#include to support nested arrays and filelists. == Version 0.5.3 * Added support for importing Rakefile and other dependencies. * Fixed bug so that now rules can chain off of existing tasks as well as existing files. * Fixed verbose flag bug in the testing task. Shortened some failure messages. * Make FileUtils methods private at the top level module to avoid accidental method leaking into other objects. * Added test loader option to test task. "testrb" is no longer the default test loader. It is now eating syntax errors that should halt the unit tests. * Revamped FileList so that it works more like and array (addressed flatten bug). Added many tests around file list. * Added +ext+ method to both String and FileList. == Version 0.5.0 * Fixed documentation that was lacking the Rake module name (Tilman Sauerbeck). * Added tar.gz and tar.bz2 support to package task (Tilman Sauerbeck). * Recursive rules are now supported (Tilman Sauerbeck). * Added warning option for the Test Task (requested by Eric Hodel). * The jamis rdoc template is only used if it exists. * Added fix for Ruby 1.8.2 test/unit and rails problem. * Added contributed rake man file (Jani Monoses). * Added Brian Candler's fix for problems in --trace and --dry-run mode. == Version 0.4.15 * Fixed a bug that prevented the TESTOPTS flag from working with the revised for 1.8.2 test task. * Updated the docs on --trace to indicate that it also enables a full backtrace on errors. == Version 0.4.14 * Modified the TestTask to workaround the Ruby 1.8.2 change in autoexecuting unit tests. == Version 0.4.13 * Fixed the dry-run flag so it is operating again. * Multiple arguments to sh and ruby commands will not be interpreted by the shell (patch provided by Jonathan Paisley). == Version 0.4.12 * Added --silent (-s) to suppress the (in directory) rake message. == Version 0.4.11 * Changed the "don't know how to rake" message (finally) * Changes references to a literal "Rakefile" to reference the global variable $rakefile (which contains the actual name of the rakefile). == Version 0.4.10 * Added block support to the "sh" command, allowing users to take special actions on the result of the system call. E.g. sh "shell_command" do |ok, res| puts "Program returned #{res.exitstatus}" if ! ok end == Version 0.4.9 * Switched to Jamis Buck's RDoc template. * Removed autorequire from Rake's gem spec. This prevents the Rake libraries from loading while using rails. == Version 0.4.8 * Added support for .rb versions of Rakefile. * Removed \\\n's from test task. * Fixed Ruby 1.9 compatibility issue with FileList. == Version 0.4.7 * Fixed problem in FileList that caused Ruby 1.9 to go into infinite recursion. Since to_a was removed from Object, it does not need to added back into the list of methods to rewrite in FileList. (Thanks to Kent Sibilev for pointing this out). == Version 0.4.6 * Removed test version of ln in FileUtils that prevented safe_ln from using ln. == Version 0.4.5 * Upgraded comments in TestTask. * FileList to_s and inspect now automatically resolve pending changes. * FileList#exclude properly returns the FileList. == Version 0.4.4 * Fixed initialization problem with @comment. * Now using multi -r technique in TestTask. Switch Rakefile back to using the built-in test task macros because the rake runtime is no longer needed. * Added 'TEST=filename' and 'TESTOPTS=options' to the Test Task macros. * Allow a +test_files+ attribute in test tasks. This allows more flexibility in specifying test files. == Version 0.4.3 * Fixed Comment leakage. == Version 0.4.2 * Added safe_ln that falls back to a copy if a file link is not supported. * Package builder now uses safe_ln. == Version 0.4.1 * Task comments are now additive, combined with "/". * Works with (soon to be released) rubygems 0.6.2 (or 0.7.0) == Version 0.4.0 * FileList now uses deferred loading. The file system is not searched until the first call that needs the file names. * VAR=VALUE options are now accepted on the command line and are treated like environment variables. The values may be tested in a Rakefile by referencing ENV['VAR']. * File.mtime is now used (instead of File.new().mtime). == Version 0.3.2.x * Removed some hidden dependencies on rubygems. Tests now will test gems only if they are installed. * Removed Sys from some example files. I believe that is that last reference to Sys outside of the contrib area. * Updated all copyright notices to include 2004. == Version 0.3.2 * GEM Installation now works with the application stub. == Version 0.3.1 * FileLists now automatically ignore CVS, .bak, ! * GEM Installation now works. == Version 0.3.0 Promoted 0.2.10. == Version 0.2.10 General * Added title to Rake's rdocs * Contrib packages are no longer included in the documentation. RDoc Issues * Removed default for the '--main' option * Fixed rendering of the rdoc options * Fixed clean/clobber confusion with rerdoc * 'title' attribute added Package Task Library Issues * Version (or explicit :noversion) is required. * +package_file+ attribute is now writable FileList Issues * Dropped bang version of exclude. Now using ant-like include/exclude semantics. * Enabled the "yield self" idiom in FileList#initialize. == Version 0.2.9 This version contains numerous changes as the RubyConf.new(2003) presentation was being prepared. The changes include: * The monolithic rubyapp task library is in the process of being dropped in favor of lighter weight task libraries. == Version 0.2.7 * Added "desc" for task descriptions. * -T will now display tasks with descriptions. * -P will display tasks and prerequisites. * Dropped the Sys module in favor of the 1.8.x FileUtils module. Sys is still supported in the contrib area. == Version 0.2.6 * Moved to RubyForge == Version 0.2.5 * Switched to standard ruby app builder. * Added no_match option to file matcher. == Version 0.2.4 * Fixed indir, which neglected to actually change directories. == Version 0.2.3 * Added rake module for a help target * Added 'for_files' to Sys * Added a $rakefile constant * Added test for selecting proper rule with multiple targets. rake-10.0.4/lib/0000755000004100000410000000000012124115317013311 5ustar www-datawww-datarake-10.0.4/lib/rake.rb0000644000004100000410000000410712124115317014562 0ustar www-datawww-data#-- # 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. #++ require 'rake/version' # :stopdoc: 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/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/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 rake-10.0.4/lib/rake/0000755000004100000410000000000012124115317014233 5ustar www-datawww-datarake-10.0.4/lib/rake/task_argument_error.rb0000644000004100000410000000016712124115317020641 0ustar www-datawww-datamodule Rake # Error indicating an ill-formed task declaration. class TaskArgumentError < ArgumentError end end rake-10.0.4/lib/rake/file_task.rb0000644000004100000410000000244212124115317016523 0ustar www-datawww-datarequire 'rake/task.rb' require 'rake/early_time' module Rake # ######################################################################### # A FileTask is a task that includes time based dependencies. If any of a # FileTask's prerequisites have a timestamp that is later than the file # represented by this task, then the file must be rebuilt (using the # supplied actions). # class FileTask < Task # Is this file task needed? Yes if it doesn't exist, or if its time stamp # is out of date. def needed? ! File.exist?(name) || out_of_date?(timestamp) end # Time stamp for file task. def timestamp if File.exist?(name) File.mtime(name.to_s) else Rake::EARLY end end private # Are there any prerequisites with a later time than the given time stamp? def out_of_date?(stamp) @prerequisites.any? { |n| application[n, @scope].timestamp > stamp} end # ---------------------------------------------------------------- # Task class methods. # class << self # Apply the scope to the task name according to the rules for this kind # of task. File based tasks ignore the scope when creating the name. def scope_name(scope, task_name) task_name end end end end rake-10.0.4/lib/rake/promise.rb0000644000004100000410000000444112124115317016241 0ustar www-datawww-datamodule Rake # A Promise object represents a promise to do work (a chore) in the # future. The promise is created with a block and a list of # arguments for the block. Calling value will return the value of # the promised chore. # # Used by ThreadPool. # class Promise # :nodoc: all NOT_SET = Object.new.freeze # :nodoc: attr_accessor :recorder # Create a promise to do the chore specified by the block. def initialize(args, &block) @mutex = Mutex.new @result = NOT_SET @error = NOT_SET @args = args @block = block end # Return the value of this promise. # # If the promised chore is not yet complete, then do the work # synchronously. We will wait. def value unless complete? stat :sleeping_on, :item_id => object_id @mutex.synchronize do stat :has_lock_on, :item_id => object_id chore stat :releasing_lock_on, :item_id => object_id end end error? ? raise(@error) : @result end # If no one else is working this promise, go ahead and do the chore. def work stat :attempting_lock_on, :item_id => object_id if @mutex.try_lock stat :has_lock_on, :item_id => object_id chore stat :releasing_lock_on, :item_id => object_id @mutex.unlock else stat :bailed_on, :item_id => object_id end end private # Perform the chore promised def chore if complete? stat :found_completed, :item_id => object_id return end stat :will_execute, :item_id => object_id begin @result = @block.call(*@args) rescue Exception => e @error = e end stat :did_execute, :item_id => object_id discard end # Do we have a result for the promise def result? ! @result.equal?(NOT_SET) end # Did the promise throw an error def error? ! @error.equal?(NOT_SET) end # Are we done with the promise def complete? result? || error? end # free up these items for the GC def discard @args = nil @block = nil end # Record execution statistics if there is a recorder def stat(*args) @recorder.call(*args) if @recorder end end end rake-10.0.4/lib/rake/phony.rb0000644000004100000410000000053712124115317015722 0ustar www-datawww-data# Defines a :phony task that you can use as a dependency. This allows # file-based tasks to use non-file-based tasks as prerequisites # without forcing them to rebuild. # # See FileTask#out_of_date? and Task#timestamp for more info. require 'rake' task :phony Rake::Task[:phony].tap do |task| def task.timestamp # :nodoc: Time.at 0 end end rake-10.0.4/lib/rake/ext/0000755000004100000410000000000012124115317015033 5ustar www-datawww-datarake-10.0.4/lib/rake/ext/module.rb0000644000004100000410000000000012124115317016633 0ustar www-datawww-datarake-10.0.4/lib/rake/ext/time.rb0000644000004100000410000000044412124115317016320 0ustar www-datawww-data#-- # Extensions to time to allow comparisons with an early time class. require 'rake/early_time' class Time alias rake_original_time_compare :<=> def <=>(other) if Rake::EarlyTime === other - other.<=>(self) else rake_original_time_compare(other) end end end rake-10.0.4/lib/rake/ext/core.rb0000644000004100000410000000131112124115317016304 0ustar www-datawww-data###################################################################### # Core extension library # class Module # Check for an existing method in the current class before extending. IF # the method already exists, then a warning is printed and the extension is # not added. Otherwise the block is yielded and any definitions in the # block will take effect. # # Usage: # # class String # rake_extension("xyz") do # def xyz # ... # end # end # end # def rake_extension(method) if method_defined?(method) $stderr.puts "WARNING: Possible conflict with Rake extension: #{self}##{method} already exists" else yield end end end rake-10.0.4/lib/rake/ext/string.rb0000644000004100000410000001314312124115317016670 0ustar www-datawww-datarequire 'rake/ext/core' ###################################################################### # Rake extension methods for String. # class String rake_extension("ext") do # Replace the file extension with +newext+. If there is no extension on # the string, append the new extension to the end. If the new extension # is not given, or is the empty string, remove any existing extension. # # +ext+ is a user added method for the String class. def ext(newext='') return self.dup if ['.', '..'].include? self if newext != '' newext = (newext =~ /^\./) ? newext : ("." + newext) end self.chomp(File.extname(self)) << newext end end rake_extension("pathmap") do # Explode a path into individual components. Used by +pathmap+. def pathmap_explode head, tail = File.split(self) return [self] if head == self return [tail] if head == '.' || tail == '/' return [head, tail] if head == '/' return head.pathmap_explode + [tail] end protected :pathmap_explode # Extract a partial path from the path. Include +n+ directories from the # front end (left hand side) if +n+ is positive. Include |+n+| # directories from the back end (right hand side) if +n+ is negative. def pathmap_partial(n) dirs = File.dirname(self).pathmap_explode partial_dirs = if n > 0 dirs[0...n] elsif n < 0 dirs.reverse[0...-n].reverse else "." end File.join(partial_dirs) end protected :pathmap_partial # Preform the pathmap replacement operations on the given path. The # patterns take the form 'pat1,rep1;pat2,rep2...'. def pathmap_replace(patterns, &block) result = self patterns.split(';').each do |pair| pattern, replacement = pair.split(',') pattern = Regexp.new(pattern) if replacement == '*' && block_given? result = result.sub(pattern, &block) elsif replacement result = result.sub(pattern, replacement) else result = result.sub(pattern, '') end end result end protected :pathmap_replace # Map the path according to the given specification. The specification # controls the details of the mapping. The following special patterns are # recognized: # # * %p -- The complete path. # * %f -- The base file name of the path, with its file extension, # but without any directories. # * %n -- The file name of the path without its file extension. # * %d -- The directory list of the path. # * %x -- The file extension of the path. An empty string if there # is no extension. # * %X -- Everything *but* the file extension. # * %s -- The alternate file separator if defined, otherwise use # the standard file separator. # * %% -- A percent sign. # # The %d specifier can also have a numeric prefix (e.g. '%2d'). If the # number is positive, only return (up to) +n+ directories in the path, # starting from the left hand side. If +n+ is negative, return (up to) # |+n+| directories from the right hand side of the path. # # Examples: # # 'a/b/c/d/file.txt'.pathmap("%2d") => 'a/b' # 'a/b/c/d/file.txt'.pathmap("%-2d") => 'c/d' # # Also the %d, %p, %f, %n, %x, and %X operators can take a # pattern/replacement argument to perform simple string substitutions on a # particular part of the path. The pattern and replacement are separated # by a comma and are enclosed by curly braces. The replacement spec comes # after the % character but before the operator letter. (e.g. # "%{old,new}d"). Multiple replacement specs should be separated by # semi-colons (e.g. "%{old,new;src,bin}d"). # # Regular expressions may be used for the pattern, and back refs may be # used in the replacement text. Curly braces, commas and semi-colons are # excluded from both the pattern and replacement text (let's keep parsing # reasonable). # # For example: # # "src/org/onestepback/proj/A.java".pathmap("%{^src,bin}X.class") # # returns: # # "bin/org/onestepback/proj/A.class" # # If the replacement text is '*', then a block may be provided to perform # some arbitrary calculation for the replacement. # # For example: # # "/path/to/file.TXT".pathmap("%X%{.*,*}x") { |ext| # ext.downcase # } # # Returns: # # "/path/to/file.txt" # def pathmap(spec=nil, &block) return self if spec.nil? result = '' spec.scan(/%\{[^}]*\}-?\d*[sdpfnxX%]|%-?\d+d|%.|[^%]+/) do |frag| case frag when '%f' result << File.basename(self) when '%n' result << File.basename(self).ext when '%d' result << File.dirname(self) when '%x' result << File.extname(self) when '%X' result << self.ext when '%p' result << self when '%s' result << (File::ALT_SEPARATOR || File::SEPARATOR) when '%-' # do nothing when '%%' result << "%" when /%(-?\d+)d/ result << pathmap_partial($1.to_i) when /^%\{([^}]*)\}(\d*[dpfnxX])/ patterns, operator = $1, $2 result << pathmap('%' + operator).pathmap_replace(patterns, &block) when /^%/ fail ArgumentError, "Unknown pathmap specifier #{frag} in '#{spec}'" else result << frag end end result end end end rake-10.0.4/lib/rake/version.rb0000644000004100000410000000027412124115317016250 0ustar www-datawww-datamodule Rake VERSION = '10.0.4' module Version # :nodoc: all MAJOR, MINOR, BUILD, = Rake::VERSION.split '.' NUMBERS = [ MAJOR, MINOR, BUILD, ] end end rake-10.0.4/lib/rake/application.rb0000644000004100000410000005033712124115317017073 0ustar www-datawww-datarequire '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 handle_options collect_tasks 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]}" puts "Total threads in play: #{stats[:total_threads_in_play]}" 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||FIXNUM_MAX) end # private ---------------------------------------------------------------- def invoke_task(task_string) name, args = parse_task_string(task_string) t = self[name] t.invoke(*args) end def parse_task_string(string) if string =~ /^([^\[]+)(\[(.*)\])$/ name = $1 args = $3.split(/\s*,\s*/) else name = string args = [] end [name, args] end # Provide standard exception handling for the given block. def standard_exception_handling begin yield rescue SystemExit => ex # 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 end # Exit the program because of an unhandle exception. # (may be overridden by subclasses) def exit_because_of_exception(ex) exit(false) end # Display the error message that caused the exception. def display_error_message(ex) trace "#{name} aborted!" trace ex.message if options.backtrace trace ex.backtrace.join("\n") else trace Backtrace.collapse(ex.backtrace).join("\n") end trace "Tasks: #{ex.chain}" if has_chain?(ex) trace "(See full trace by running task with --trace)" unless options.backtrace end # Warn about deprecated usage. # # Example: # Rake.application.deprecate("import", "Rake.import", caller.first) # def deprecate(old_usage, new_usage, call_site) 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) 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 @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? @tty_output end # Override the detected TTY output state (mostly for testing) def tty_output=( tty_output_state ) @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? tty_output? || @terminal_columns.nonzero? end # Display the tasks and comments. def display_tasks_and_comments 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.collect { |t| t.name_with_args.length }.max || 10 max_column = truncate_output? ? terminal_width - name.size - width - 7 : nil 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 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 @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? RbConfig::CONFIG['host_os'] =~ /(aix|darwin|linux|(net|free|open)bsd|cygwin|solaris|irix|hpux)/i end def windows? Win32.windows? end def truncate(string, width) if string.nil? "" elsif string.length <= width string else ( string[0, width-3] || "" ) + "..." end end # Display the tasks and prerequisites def display_prerequisites tasks.each do |t| puts "#{name} #{t.name}" t.prerequisites.each { |pre| puts " #{pre}" } end end def trace(*strings) options.trace_output ||= $stderr trace_on(options.trace_output, *strings) end def sort_options(options) 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 sort_options( [ ['--all', '-A', "Show all tasks, even uncommented ones", 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) } ], ['--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:2)", lambda { |value| options.thread_pool_size = [(value || 2).to_i,2].max } ], ['--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 [FILE]', "Use FILE as the rakefile.", 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) 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) 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. def handle_options options.rakelib = ['rakelib'] options.trace_output = $stderr OptionParser.new do |opts| opts.banner = "rake [-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! 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=$") 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 here = Dir.pwd while ! (fn = have_rakefile) Dir.chdir("..") if Dir.pwd == here || options.nosearch return nil end here = Dir.pwd end [fn, here] ensure Dir.chdir(Rake.original_dir) end def print_rakefile_directory(location) $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) FileList.glob(path.gsub("\\", '/')).each(&block) end private :glob # The directory path containing the system wide rakefiles. def system_dir @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. def collect_tasks @top_level_tasks = [] ARGV.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 "default" end # Add a file to the list of files to be imported. def add_import(fn) @pending_imports << fn end # Load the pending list of imported files. def load_imports while fn = @pending_imports.shift next if @imported.member?(fn) if fn_task = lookup(fn) fn_task.invoke end ext = File.extname(fn) loader = @loaders[ext] || @default_loader loader.load(fn) @imported << fn end end def rakefile_location(backtrace=caller) 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 rake-10.0.4/lib/rake/runtest.rb0000644000004100000410000000072412124115317016267 0ustar www-datawww-datarequire 'test/unit' require 'test/unit/assertions' require 'rake/file_list' module Rake include Test::Unit::Assertions def run_tests(pattern='test/test*.rb', log_enabled=false) FileList.glob(pattern).each { |fn| $stderr.puts fn if log_enabled begin require fn rescue Exception => ex $stderr.puts "Error in #{fn}: #{ex.message}" $stderr.puts ex.backtrace assert false end } end extend self end rake-10.0.4/lib/rake/task.rb0000644000004100000410000002524712124115317015534 0ustar www-datawww-datarequire 'rake/invocation_exception_mixin' module Rake # ######################################################################### # A Task is the basic unit of work in a Rakefile. Tasks have associated # actions (possibly more than one) and a list of prerequisites. When # invoked, a task will first ensure that all of its prerequisites have an # opportunity to run and then it will execute its own actions. # # Tasks are not usually created directly using the new method, but rather # use the +file+ and +task+ convenience methods. # class Task # List of prerequisites for a task. attr_reader :prerequisites # List of actions attached to a task. attr_reader :actions # Application owning this task. attr_accessor :application # Comment for this task. Restricted to a single line of no more than 50 # characters. attr_reader :comment # Full text of the (possibly multi-line) comment. attr_reader :full_comment # Array of nested namespaces names used for task lookup by this task. attr_reader :scope # File/Line locations of each of the task definitions for this # task (only valid if the task was defined with the detect # location option set). attr_reader :locations # Return task name def to_s name end def inspect "<#{self.class} #{name} => [#{prerequisites.join(', ')}]>" end # List of sources for task. attr_writer :sources def sources @sources ||= [] end # List of prerequisite tasks def prerequisite_tasks prerequisites.collect { |pre| lookup_prerequisite(pre) } end def lookup_prerequisite(prerequisite_name) application[prerequisite_name, @scope] end private :lookup_prerequisite # List of all unique prerequisite tasks including prerequisite tasks' # prerequisites. # Includes self when cyclic dependencies are found. def all_prerequisite_tasks seen = {} collect_prerequisites(seen) seen.values end def collect_prerequisites(seen) prerequisite_tasks.each do |pre| next if seen[pre.name] seen[pre.name] = pre pre.collect_prerequisites(seen) end end protected :collect_prerequisites # First source from a rule (nil if no sources) def source @sources.first if defined?(@sources) end # Create a task named +task_name+ with no actions or prerequisites. Use # +enhance+ to add actions and prerequisites. def initialize(task_name, app) @name = task_name.to_s @prerequisites = [] @actions = [] @already_invoked = false @full_comment = nil @comment = nil @lock = Monitor.new @application = app @scope = app.current_scope @arg_names = nil @locations = [] end # Enhance a task with prerequisites or actions. Returns self. def enhance(deps=nil, &block) @prerequisites |= deps if deps @actions << block if block_given? self end # Name of the task, including any namespace qualifiers. def name @name.to_s end # Name of task with argument list description. def name_with_args # :nodoc: if arg_description "#{name}#{arg_description}" else name end end # Argument description (nil if none). def arg_description # :nodoc: @arg_names ? "[#{arg_names.join(',')}]" : nil end # Name of arguments for this task. def arg_names @arg_names || [] end # Reenable the task, allowing its tasks to be executed if the task # is invoked again. def reenable @already_invoked = false end # Clear the existing prerequisites and actions of a rake task. def clear clear_prerequisites clear_actions clear_comments self end # Clear the existing prerequisites of a rake task. def clear_prerequisites prerequisites.clear self end # Clear the existing actions on a rake task. def clear_actions actions.clear self end # Clear the existing comments on a rake task. def clear_comments @full_comment = nil @comment = nil self end # Invoke the task if it is needed. Prerequisites are invoked first. def invoke(*args) task_args = TaskArguments.new(arg_names, args) invoke_with_call_chain(task_args, InvocationChain::EMPTY) end # Same as invoke, but explicitly pass a call chain to detect # circular dependencies. def invoke_with_call_chain(task_args, invocation_chain) # :nodoc: new_chain = InvocationChain.append(self, invocation_chain) @lock.synchronize do if application.options.trace application.trace "** Invoke #{name} #{format_trace_flags}" end return if @already_invoked @already_invoked = true invoke_prerequisites(task_args, new_chain) execute(task_args) if needed? end rescue Exception => ex add_chain_to(ex, new_chain) raise ex end protected :invoke_with_call_chain def add_chain_to(exception, new_chain) exception.extend(InvocationExceptionMixin) unless exception.respond_to?(:chain) exception.chain = new_chain if exception.chain.nil? end private :add_chain_to # Invoke all the prerequisites of a task. def invoke_prerequisites(task_args, invocation_chain) # :nodoc: if application.options.always_multitask invoke_prerequisites_concurrently(task_args, invocation_chain) else prerequisite_tasks.each { |p| prereq_args = task_args.new_scope(p.arg_names) p.invoke_with_call_chain(prereq_args, invocation_chain) } end end # Invoke all the prerequisites of a task in parallel. def invoke_prerequisites_concurrently(task_args, invocation_chain) # :nodoc: futures = prerequisite_tasks.collect do |p| prereq_args = task_args.new_scope(p.arg_names) application.thread_pool.future(p) do |r| r.invoke_with_call_chain(prereq_args, invocation_chain) end end futures.each { |f| f.value } end # Format the trace flags for display. def format_trace_flags flags = [] flags << "first_time" unless @already_invoked flags << "not_needed" unless needed? flags.empty? ? "" : "(" + flags.join(", ") + ")" end private :format_trace_flags # Execute the actions associated with this task. def execute(args=nil) args ||= EMPTY_TASK_ARGS if application.options.dryrun application.trace "** Execute (dry run) #{name}" return end if application.options.trace application.trace "** Execute #{name}" end application.enhance_with_matching_rule(name) if @actions.empty? @actions.each do |act| case act.arity when 1 act.call(self) else act.call(self, args) end end end # Is this task needed? def needed? true end # Timestamp for this task. Basic tasks return the current time for their # time stamp. Other tasks can be more sophisticated. def timestamp Time.now end # Add a description to the task. The description can consist of an option # argument list (enclosed brackets) and an optional comment. def add_description(description) return if ! description comment = description.strip add_comment(comment) if comment && ! comment.empty? end # Writing to the comment attribute is the same as adding a description. def comment=(description) add_description(description) end # Add a comment to the task. If a comment already exists, separate # the new comment with " / ". def add_comment(comment) if @full_comment @full_comment << " / " else @full_comment = '' end @full_comment << comment if @full_comment =~ /\A([^.]+?\.)( |$)/ @comment = $1 else @comment = @full_comment end end private :add_comment # Set the names of the arguments for this task. +args+ should be # an array of symbols, one for each argument name. def set_arg_names(args) @arg_names = args.map { |a| a.to_sym } end # Return a string describing the internal state of a task. Useful for # debugging. def investigation result = "------------------------------\n" result << "Investigating #{name}\n" result << "class: #{self.class}\n" result << "task needed: #{needed?}\n" result << "timestamp: #{timestamp}\n" result << "pre-requisites: \n" prereqs = prerequisite_tasks prereqs.sort! {|a,b| a.timestamp <=> b.timestamp} prereqs.each do |p| result << "--#{p.name} (#{p.timestamp})\n" end latest_prereq = prerequisite_tasks.collect { |pre| pre.timestamp }.max result << "latest-prerequisite time: #{latest_prereq}\n" result << "................................\n\n" return result end # ---------------------------------------------------------------- # Rake Module Methods # class << self # Clear the task list. This cause rake to immediately forget all the # tasks that have been assigned. (Normally used in the unit tests.) def clear Rake.application.clear end # List of all defined tasks. def tasks Rake.application.tasks end # Return a task with the given name. If the task is not currently # known, try to synthesize one from the defined rules. If no rules are # found, but an existing file matches the task name, assume it is a file # task with no dependencies or actions. def [](task_name) Rake.application[task_name] end # TRUE if the task name is already defined. def task_defined?(task_name) Rake.application.lookup(task_name) != nil end # Define a task given +args+ and an option block. If a rule with the # given name already exists, the prerequisites and actions are added to # the existing task. Returns the defined task. def define_task(*args, &block) Rake.application.define_task(self, *args, &block) end # Define a rule for synthesizing tasks. def create_rule(*args, &block) Rake.application.create_rule(*args, &block) end # Apply the scope to the task name according to the rules for # this kind of task. Generic tasks will accept the scope as # part of the name. def scope_name(scope, task_name) (scope + [task_name]).join(':') end end # class << Rake::Task end # class Rake::Task end rake-10.0.4/lib/rake/backtrace.rb0000644000004100000410000000124212124115317016476 0ustar www-datawww-datamodule Rake module Backtrace SUPPRESSED_PATHS = RbConfig::CONFIG.values_at(*RbConfig::CONFIG. keys.grep(/(prefix|libdir)/)).uniq + [ File.join(File.dirname(__FILE__), ".."), ].map { |f| Regexp.quote(File.expand_path(f)) } SUPPRESSED_PATHS.map! { |s| s.gsub("\\", "/") } SUPPRESSED_PATHS.reject! { |s| s.nil? || s =~ /^ *$/ } SUPPRESS_PATTERN = %r!(\A#{SUPPRESSED_PATHS.join('|')}|bin/rake:\d+)!i def self.collapse(backtrace) pattern = Rake.application.options.suppress_backtrace_pattern || SUPPRESS_PATTERN backtrace.reject { |elem| elem =~ pattern } end end end rake-10.0.4/lib/rake/file_creation_task.rb0000644000004100000410000000123612124115317020407 0ustar www-datawww-datarequire 'rake/file_task' require 'rake/early_time' module Rake # A FileCreationTask is a file task that when used as a dependency will be # needed if and only if the file has not been created. Once created, it is # not re-triggered if any of its dependencies are newer, nor does trigger # any rebuilds of tasks that depend on it whenever it is updated. # class FileCreationTask < FileTask # Is this file task needed? Yes if it doesn't exist. def needed? ! File.exist?(name) end # Time stamp for file creation task. This time stamp is earlier # than any other time stamp. def timestamp Rake::EARLY end end end rake-10.0.4/lib/rake/private_reader.rb0000644000004100000410000000055412124115317017560 0ustar www-datawww-datamodule Rake # Include PrivateReader to use +private_reader+. module PrivateReader # :nodoc: all def self.included(base) base.extend(ClassMethods) end module ClassMethods # Declare a list of private accessors def private_reader(*names) attr_reader(*names) private(*names) end end end end rake-10.0.4/lib/rake/file_list.rb0000644000004100000410000002677412124115317016552 0ustar www-datawww-datarequire 'rake/cloneable' require 'rake/file_utils_ext' require 'rake/pathmap' ###################################################################### module Rake # ######################################################################### # A FileList is essentially an array with a few helper methods defined to # make file manipulation a bit easier. # # FileLists are lazy. When given a list of glob patterns for possible files # to be included in the file list, instead of searching the file structures # to find the files, a FileList holds the pattern for latter use. # # This allows us to define a number of FileList to match any number of # files, but only search out the actual files when then FileList itself is # actually used. The key is that the first time an element of the # FileList/Array is requested, the pending patterns are resolved into a real # list of file names. # class FileList include Cloneable # == Method Delegation # # The lazy evaluation magic of FileLists happens by implementing all the # array specific methods to call +resolve+ before delegating the heavy # lifting to an embedded array object (@items). # # In addition, there are two kinds of delegation calls. The regular kind # delegates to the @items array and returns the result directly. Well, # almost directly. It checks if the returned value is the @items object # itself, and if so will return the FileList object instead. # # The second kind of delegation call is used in methods that normally # return a new Array object. We want to capture the return value of these # methods and wrap them in a new FileList object. We enumerate these # methods in the +SPECIAL_RETURN+ list below. # List of array methods (that are not in +Object+) that need to be # delegated. ARRAY_METHODS = (Array.instance_methods - Object.instance_methods).map { |n| n.to_s } # List of additional methods that must be delegated. MUST_DEFINE = %w[to_a inspect <=>] # List of methods that should not be delegated here (we define special # versions of them explicitly below). MUST_NOT_DEFINE = %w[to_a to_ary partition *] # List of delegated methods that return new array values which need # wrapping. SPECIAL_RETURN = %w[ map collect sort sort_by select find_all reject grep compact flatten uniq values_at + - & | ] DELEGATING_METHODS = (ARRAY_METHODS + MUST_DEFINE - MUST_NOT_DEFINE).collect{ |s| s.to_s }.sort.uniq # Now do the delegation. DELEGATING_METHODS.each_with_index do |sym, i| if SPECIAL_RETURN.include?(sym) ln = __LINE__+1 class_eval %{ def #{sym}(*args, &block) resolve result = @items.send(:#{sym}, *args, &block) FileList.new.import(result) end }, __FILE__, ln else ln = __LINE__+1 class_eval %{ def #{sym}(*args, &block) resolve result = @items.send(:#{sym}, *args, &block) result.object_id == @items.object_id ? self : result end }, __FILE__, ln end end # Create a file list from the globbable patterns given. If you wish to # perform multiple includes or excludes at object build time, use the # "yield self" pattern. # # Example: # file_list = FileList.new('lib/**/*.rb', 'test/test*.rb') # # pkg_files = FileList.new('lib/**/*') do |fl| # fl.exclude(/\bCVS\b/) # end # def initialize(*patterns) @pending_add = [] @pending = false @exclude_patterns = DEFAULT_IGNORE_PATTERNS.dup @exclude_procs = DEFAULT_IGNORE_PROCS.dup @items = [] patterns.each { |pattern| include(pattern) } yield self if block_given? end # Add file names defined by glob patterns to the file list. If an array # is given, add each element of the array. # # Example: # file_list.include("*.java", "*.cfg") # file_list.include %w( math.c lib.h *.o ) # def include(*filenames) # TODO: check for pending filenames.each do |fn| if fn.respond_to? :to_ary include(*fn.to_ary) else @pending_add << fn end end @pending = true self end alias :add :include # Register a list of file name patterns that should be excluded from the # list. Patterns may be regular expressions, glob patterns or regular # strings. In addition, a block given to exclude will remove entries that # return true when given to the block. # # Note that glob patterns are expanded against the file system. If a file # is explicitly added to a file list, but does not exist in the file # system, then an glob pattern in the exclude list will not exclude the # file. # # Examples: # FileList['a.c', 'b.c'].exclude("a.c") => ['b.c'] # FileList['a.c', 'b.c'].exclude(/^a/) => ['b.c'] # # If "a.c" is a file, then ... # FileList['a.c', 'b.c'].exclude("a.*") => ['b.c'] # # If "a.c" is not a file, then ... # FileList['a.c', 'b.c'].exclude("a.*") => ['a.c', 'b.c'] # def exclude(*patterns, &block) patterns.each do |pat| @exclude_patterns << pat end if block_given? @exclude_procs << block end resolve_exclude if ! @pending self end # Clear all the exclude patterns so that we exclude nothing. def clear_exclude @exclude_patterns = [] @exclude_procs = [] self end # Define equality. def ==(array) to_ary == array end # Return the internal array object. def to_a resolve @items end # Return the internal array object. def to_ary to_a end # Lie about our class. def is_a?(klass) klass == Array || super(klass) end alias kind_of? is_a? # Redefine * to return either a string or a new file list. def *(other) result = @items * other case result when Array FileList.new.import(result) else result end end # Resolve all the pending adds now. def resolve if @pending @pending = false @pending_add.each do |fn| resolve_add(fn) end @pending_add = [] resolve_exclude end self end def resolve_add(fn) case fn when %r{[*?\[\{]} add_matching(fn) else self << fn end end private :resolve_add def resolve_exclude reject! { |fn| exclude?(fn) } self end private :resolve_exclude # Return a new FileList with the results of running +sub+ against each # element of the original list. # # Example: # FileList['a.c', 'b.c'].sub(/\.c$/, '.o') => ['a.o', 'b.o'] # def sub(pat, rep) inject(FileList.new) { |res, fn| res << fn.sub(pat,rep) } end # Return a new FileList with the results of running +gsub+ against each # element of the original list. # # Example: # FileList['lib/test/file', 'x/y'].gsub(/\//, "\\") # => ['lib\\test\\file', 'x\\y'] # def gsub(pat, rep) inject(FileList.new) { |res, fn| res << fn.gsub(pat,rep) } end # Same as +sub+ except that the original file list is modified. def sub!(pat, rep) each_with_index { |fn, i| self[i] = fn.sub(pat,rep) } self end # Same as +gsub+ except that the original file list is modified. def gsub!(pat, rep) each_with_index { |fn, i| self[i] = fn.gsub(pat,rep) } self end # Apply the pathmap spec to each of the included file names, returning a # new file list with the modified paths. (See String#pathmap for # details.) def pathmap(spec=nil) collect { |fn| fn.pathmap(spec) } end # Return a new FileList with String#ext method applied to # each member of the array. # # This method is a shortcut for: # # array.collect { |item| item.ext(newext) } # # +ext+ is a user added method for the Array class. def ext(newext='') collect { |fn| fn.ext(newext) } end # Grep each of the files in the filelist using the given pattern. If a # block is given, call the block on each matching line, passing the file # name, line number, and the matching line of text. If no block is given, # a standard emacs style file:linenumber:line message will be printed to # standard out. Returns the number of matched items. def egrep(pattern, *options) matched = 0 each do |fn| begin open(fn, "r", *options) do |inf| count = 0 inf.each do |line| count += 1 if pattern.match(line) matched += 1 if block_given? yield fn, count, line else puts "#{fn}:#{count}:#{line}" end end end end rescue StandardError => ex $stderr.puts "Error while processing '#{fn}': #{ex}" end end matched end # Return a new file list that only contains file names from the current # file list that exist on the file system. def existing select { |fn| File.exist?(fn) } end # Modify the current file list so that it contains only file name that # exist on the file system. def existing! resolve @items = @items.select { |fn| File.exist?(fn) } self end # FileList version of partition. Needed because the nested arrays should # be FileLists in this version. def partition(&block) # :nodoc: resolve result = @items.partition(&block) [ FileList.new.import(result[0]), FileList.new.import(result[1]), ] end # Convert a FileList to a string by joining all elements with a space. def to_s resolve self.join(' ') end # Add matching glob patterns. def add_matching(pattern) FileList.glob(pattern).each do |fn| self << fn unless exclude?(fn) end end private :add_matching # Should the given file name be excluded? def exclude?(fn) return true if @exclude_patterns.any? do |pat| case pat when Regexp fn =~ pat when /[*?]/ File.fnmatch?(pat, fn, File::FNM_PATHNAME) else fn == pat end end @exclude_procs.any? { |p| p.call(fn) } end DEFAULT_IGNORE_PATTERNS = [ /(^|[\/\\])CVS([\/\\]|$)/, /(^|[\/\\])\.svn([\/\\]|$)/, /\.bak$/, /~$/ ] DEFAULT_IGNORE_PROCS = [ proc { |fn| fn =~ /(^|[\/\\])core$/ && ! File.directory?(fn) } ] def import(array) @items = array self end class << self # Create a new file list including the files listed. Similar to: # # FileList.new(*args) def [](*args) new(*args) end # Get a sorted list of files matching the pattern. This method # should be prefered to Dir[pattern] and Dir.glob(pattern) because # the files returned are guaranteed to be sorted. def glob(pattern, *args) Dir.glob(pattern, *args).sort end end end end module Rake class << self # Yield each file or directory component. def each_dir_parent(dir) # :nodoc: old_length = nil while dir != '.' && dir.length != old_length yield(dir) old_length = dir.length dir = File.dirname(dir) end end end end # module Rake rake-10.0.4/lib/rake/early_time.rb0000644000004100000410000000042112124115317016707 0ustar www-datawww-datamodule Rake # EarlyTime is a fake timestamp that occurs _before_ any other time value. class EarlyTime include Comparable include Singleton def <=>(other) -1 end def to_s "" end end EARLY = EarlyTime.instance end rake-10.0.4/lib/rake/rake_module.rb0000644000004100000410000000132712124115317017052 0ustar www-datawww-datarequire 'rake/application' module Rake # Rake module singleton methods. # class << self # Current Rake Application def application @application ||= Rake::Application.new end # Set the current Rake application object. def application=(app) @application = app end # Return the original directory where the Rake application was started. def original_dir application.original_dir end # Load a rakefile. def load_rakefile(path) load(path) end # Add files to the rakelib list def add_rakelib(*files) application.options.rakelib ||= [] files.each do |file| application.options.rakelib << file end end end end rake-10.0.4/lib/rake/task_arguments.rb0000644000004100000410000000320412124115317017606 0ustar www-datawww-datamodule Rake #################################################################### # TaskArguments manage the arguments passed to a task. # class TaskArguments include Enumerable attr_reader :names # Create a TaskArgument object with a list of named arguments # (given by :names) and a set of associated values (given by # :values). :parent is the parent argument object. def initialize(names, values, parent=nil) @names = names @parent = parent @hash = {} names.each_with_index { |name, i| @hash[name.to_sym] = values[i] unless values[i].nil? } end # Create a new argument scope using the prerequisite argument # names. def new_scope(names) values = names.collect { |n| self[n] } self.class.new(names, values, self) end # Find an argument value by name or index. def [](index) lookup(index.to_sym) end # Specify a hash of default values for task arguments. Use the # defaults only if there is no specific value for the given # argument. def with_defaults(defaults) @hash = defaults.merge(@hash) end def each(&block) @hash.each(&block) end def values_at(*keys) keys.map { |k| lookup(k) } end def method_missing(sym, *args) lookup(sym.to_sym) end def to_hash @hash end def to_s @hash.inspect end def inspect to_s end protected def lookup(name) if @hash.has_key?(name) @hash[name] elsif @parent @parent.lookup(name) end end end EMPTY_TASK_ARGS = TaskArguments.new([], []) end rake-10.0.4/lib/rake/alt_system.rb0000644000004100000410000000621412124115317016747 0ustar www-datawww-data# # 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. # module Rake::AltSystem 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 and 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| if File.exist?(test = "#{file}.#{ext}") return test end } 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 rake-10.0.4/lib/rake/pseudo_status.rb0000644000004100000410000000064612124115317017470 0ustar www-datawww-datamodule Rake #################################################################### # Exit status class for times the system just gives us a nil. class PseudoStatus attr_reader :exitstatus def initialize(code=0) @exitstatus = code end def to_i @exitstatus << 8 end def >>(n) to_i >> n end def stopped? false end def exited? true end end end rake-10.0.4/lib/rake/win32.rb0000644000004100000410000000303212124115317015520 0ustar www-datawww-data module Rake require 'rake/alt_system' # Win 32 interface methods for Rake. Windows specific functionality # will be placed here to collect that knowledge in one spot. module Win32 # Error indicating a problem in locating the home directory on a # Win32 system. class Win32HomeError < RuntimeError end class << self # True if running on a windows system. def windows? AltSystem::WINDOWS end # Run a command line on windows. def rake_system(*cmd) AltSystem.system(*cmd) end # The standard directory containing system wide rake files on # Win 32 systems. Try the following environment variables (in # order): # # * HOME # * HOMEDRIVE + HOMEPATH # * APPDATA # * USERPROFILE # # If the above are not defined, the return nil. def win32_system_dir #:nodoc: win32_shared_path = ENV['HOME'] if win32_shared_path.nil? && ENV['HOMEDRIVE'] && ENV['HOMEPATH'] win32_shared_path = ENV['HOMEDRIVE'] + ENV['HOMEPATH'] end win32_shared_path ||= ENV['APPDATA'] win32_shared_path ||= ENV['USERPROFILE'] raise Win32HomeError, "Unable to determine home path environment variable." if win32_shared_path.nil? or win32_shared_path.empty? normalize(File.join(win32_shared_path, 'Rake')) end # Normalize a win32 path so that the slashes are all forward slashes. def normalize(path) path.gsub(/\\/, '/') end end end end rake-10.0.4/lib/rake/cloneable.rb0000644000004100000410000000074212124115317016507 0ustar www-datawww-datamodule Rake # ########################################################################## # Mixin for creating easily cloned objects. # module Cloneable # The hook that invoked by 'clone' and 'dup' methods. def initialize_copy(source) super source.instance_variables.each do |var| src_value = source.instance_variable_get(var) value = src_value.clone rescue src_value instance_variable_set(var, value) end end end end rake-10.0.4/lib/rake/multi_task.rb0000644000004100000410000000047312124115317016740 0ustar www-datawww-datamodule Rake # Same as a regular task, but the immediate prerequisites are done in # parallel using Ruby threads. # class MultiTask < Task private def invoke_prerequisites(task_args, invocation_chain) # :nodoc: invoke_prerequisites_concurrently(task_args, invocation_chain) end end end rake-10.0.4/lib/rake/name_space.rb0000644000004100000410000000115212124115317016652 0ustar www-datawww-datamodule Rake # The NameSpace class will lookup task names in the the scope # defined by a +namespace+ command. # class NameSpace # Create a namespace lookup object using the given task manager # and the list of scopes. def initialize(task_manager, scope_list) @task_manager = task_manager @scope = scope_list.dup end # Lookup a task named +name+ in the namespace. def [](name) @task_manager.lookup(name, @scope) end # Return the list of tasks defined in this and nested namespaces. def tasks @task_manager.tasks_in_scope(@scope) end end end rake-10.0.4/lib/rake/loaders/0000755000004100000410000000000012124115317015664 5ustar www-datawww-datarake-10.0.4/lib/rake/loaders/makefile.rb0000644000004100000410000000162212124115317017767 0ustar www-datawww-datamodule Rake # Makefile loader to be used with the import file loader. class MakefileLoader include Rake::DSL SPACE_MARK = "\0" # Load the makefile dependencies in +fn+. def load(fn) lines = File.read fn lines.gsub!(/\\ /, SPACE_MARK) lines.gsub!(/#[^\n]*\n/m, "") lines.gsub!(/\\\n/, ' ') lines.each_line do |line| process_line(line) end end private # Process one logical line of makefile data. def process_line(line) file_tasks, args = line.split(':', 2) return if args.nil? dependents = args.split.map { |d| respace(d) } file_tasks.scan(/\S+/) do |file_task| file_task = respace(file_task) file file_task => dependents end end def respace(str) str.tr SPACE_MARK, ' ' end end # Install the handler Rake.application.add_loader('mf', MakefileLoader.new) end rake-10.0.4/lib/rake/rule_recursion_overflow_error.rb0000644000004100000410000000054112124115317022754 0ustar www-datawww-data module Rake # Error indicating a recursion overflow error in task selection. class RuleRecursionOverflowError < StandardError def initialize(*args) super @targets = [] end def add_target(target) @targets << target end def message super + ": [" + @targets.reverse.join(' => ') + "]" end end end rake-10.0.4/lib/rake/gempackagetask.rb0000644000004100000410000000015612124115317017531 0ustar www-datawww-datafail "ERROR: 'rake/gempackagetask' is obsolete and no longer supported. Use 'rubygems/package_task' instead." rake-10.0.4/lib/rake/contrib/0000755000004100000410000000000012124115317015673 5ustar www-datawww-datarake-10.0.4/lib/rake/contrib/sshpublisher.rb0000644000004100000410000000231212124115317020731 0ustar www-datawww-datarequire 'rake/dsl_definition' require 'rake/contrib/compositepublisher' module Rake # Publish an entire directory to an existing remote directory using # SSH. class SshDirPublisher include Rake::DSL def initialize(host, remote_dir, local_dir) @host = host @remote_dir = remote_dir @local_dir = local_dir end def upload sh %{scp -rq #{@local_dir}/* #{@host}:#{@remote_dir}} end end # Publish an entire directory to a fresh remote directory using SSH. class SshFreshDirPublisher < SshDirPublisher def upload sh %{ssh #{@host} rm -rf #{@remote_dir}} rescue nil sh %{ssh #{@host} mkdir #{@remote_dir}} super end end # Publish a list of files to an existing remote directory. class SshFilePublisher include Rake::DSL # Create a publisher using the give host information. def initialize(host, remote_dir, local_dir, *files) @host = host @remote_dir = remote_dir @local_dir = local_dir @files = files end # Upload the local directory to the remote directory. def upload @files.each do |fn| sh %{scp -q #{@local_dir}/#{fn} #{@host}:#{@remote_dir}} end end end end rake-10.0.4/lib/rake/contrib/ftptools.rb0000644000004100000410000000731612124115317020101 0ustar www-datawww-data# = Tools for FTP uploading. # # This file is still under development and is not released for general # use. require 'date' require 'net/ftp' require 'rake/file_list' module Rake # :nodoc: #################################################################### # Note: Not released for general use. class FtpFile attr_reader :name, :size, :owner, :group, :time def self.date @date_class ||= Date end def self.time @time_class ||= Time end def initialize(path, entry) @path = path @mode, _, @owner, @group, size, d1, d2, d3, @name = entry.split(' ') @size = size.to_i @time = determine_time(d1, d2, d3) end def path File.join(@path, @name) end def directory? @mode[0] == ?d end def mode parse_mode(@mode) end def symlink? @mode[0] == ?l end private # -------------------------------------------------------- def parse_mode(m) result = 0 (1..9).each do |i| result = 2*result + ((m[i]==?-) ? 0 : 1) end result end def determine_time(d1, d2, d3) now = self.class.time.now if /:/ =~ d3 result = Time.parse("#{d1} #{d2} #{now.year} #{d3}") if result > now result = Time.parse("#{d1} #{d2} #{now.year-1} #{d3}") end else result = Time.parse("#{d1} #{d2} #{d3}") end result # elements = ParseDate.parsedate("#{d1} #{d2} #{d3}") # if elements[0].nil? # today = self.class.date.today # if elements[1] > today.month # elements[0] = today.year - 1 # else # elements[0] = today.year # end # end # elements = elements.collect { |el| el.nil? ? 0 : el } # Time.mktime(*elements[0,7]) end end #################################################################### # Manage the uploading of files to an FTP account. class FtpUploader # Log uploads to standard output when true. attr_accessor :verbose class << FtpUploader # Create an uploader and pass it to the given block as +up+. # When the block is complete, close the uploader. def connect(path, host, account, password) up = self.new(path, host, account, password) begin yield(up) ensure up.close end end end # Create an FTP uploader targeting the directory +path+ on +host+ # using the given account and password. +path+ will be the root # path of the uploader. def initialize(path, host, account, password) @created = Hash.new @path = path @ftp = Net::FTP.new(host, account, password) makedirs(@path) @ftp.chdir(@path) end # Create the directory +path+ in the uploader root path. def makedirs(path) route = [] File.split(path).each do |dir| route << dir current_dir = File.join(route) if @created[current_dir].nil? @created[current_dir] = true $stderr.puts "Creating Directory #{current_dir}" if @verbose @ftp.mkdir(current_dir) rescue nil end end end # Upload all files matching +wildcard+ to the uploader's root # path. def upload_files(wildcard) FileList.glob(wildcard).each do |fn| upload(fn) end end # Close the uploader. def close @ftp.close end private # -------------------------------------------------------- # Upload a single file to the uploader's root path. def upload(file) $stderr.puts "Uploading #{file}" if @verbose dir = File.dirname(file) makedirs(dir) @ftp.putbinaryfile(file, file) unless File.directory?(file) end end end rake-10.0.4/lib/rake/contrib/rubyforgepublisher.rb0000644000004100000410000000045612124115317022147 0ustar www-datawww-datarequire 'rake/contrib/sshpublisher' module Rake class RubyForgePublisher < SshDirPublisher attr_reader :project, :proj_id, :user def initialize(projname, user) super( "#{user}@rubyforge.org", "/var/www/gforge-projects/#{projname}", "html") end end end rake-10.0.4/lib/rake/contrib/sys.rb0000644000004100000410000000013712124115317017037 0ustar www-datawww-datafail "ERROR: 'rake/contrib/sys' is obsolete and no longer supported. Use 'FileUtils' instead." rake-10.0.4/lib/rake/contrib/publisher.rb0000644000004100000410000000344412124115317020222 0ustar www-datawww-data# Copyright 2003-2010 by Jim Weirich (jim.weirich@gmail.com) # All rights reserved. # :stopdoc: # Configuration information about an upload host system. # name :: Name of host system. # webdir :: Base directory for the web information for the # application. The application name (APP) is appended to # this directory before using. # pkgdir :: Directory on the host system where packages can be # placed. HostInfo = Struct.new(:name, :webdir, :pkgdir) # :startdoc: # Manage several publishers as a single entity. class CompositePublisher def initialize @publishers = [] end # Add a publisher to the composite. def add(pub) @publishers << pub end # Upload all the individual publishers. def upload @publishers.each { |p| p.upload } end end # Publish an entire directory to an existing remote directory using # SSH. class SshDirPublisher def initialize(host, remote_dir, local_dir) @host = host @remote_dir = remote_dir @local_dir = local_dir end def upload run %{scp -rq #{@local_dir}/* #{@host}:#{@remote_dir}} end end # Publish an entire directory to a fresh remote directory using SSH. class SshFreshDirPublisher < SshDirPublisher def upload run %{ssh #{@host} rm -rf #{@remote_dir}} rescue nil run %{ssh #{@host} mkdir #{@remote_dir}} super end end # Publish a list of files to an existing remote directory. class SshFilePublisher # Create a publisher using the give host information. def initialize(host, remote_dir, local_dir, *files) @host = host @remote_dir = remote_dir @local_dir = local_dir @files = files end # Upload the local directory to the remote directory. def upload @files.each do |fn| run %{scp -q #{@local_dir}/#{fn} #{@host}:#{@remote_dir}} end end end rake-10.0.4/lib/rake/contrib/compositepublisher.rb0000644000004100000410000000053712124115317022145 0ustar www-datawww-datamodule Rake # Manage several publishers as a single entity. class CompositePublisher def initialize @publishers = [] end # Add a publisher to the composite. def add(pub) @publishers << pub end # Upload all the individual publishers. def upload @publishers.each { |p| p.upload } end end end rake-10.0.4/lib/rake/invocation_exception_mixin.rb0000644000004100000410000000065712124115317022223 0ustar www-datawww-datamodule Rake module InvocationExceptionMixin # Return the invocation chain (list of Rake tasks) that were in # effect when this exception was detected by rake. May be null if # no tasks were active. def chain @rake_invocation_chain ||= nil end # Set the invocation chain in effect when this exception was # detected. def chain=(value) @rake_invocation_chain = value end end end rake-10.0.4/lib/rake/file_utils_ext.rb0000644000004100000410000001005512124115317017600 0ustar www-datawww-datarequire 'rake/file_utils' module Rake # # FileUtilsExt provides a custom version of the FileUtils methods # that respond to the verbose and nowrite # commands. # module FileUtilsExt include FileUtils class << self attr_accessor :verbose_flag, :nowrite_flag end DEFAULT = Object.new FileUtilsExt.verbose_flag = DEFAULT FileUtilsExt.nowrite_flag = false FileUtils.commands.each do |name| opts = FileUtils.options_of name default_options = [] if opts.include?("verbose") default_options << ':verbose => FileUtilsExt.verbose_flag' end if opts.include?("noop") default_options << ':noop => FileUtilsExt.nowrite_flag' end next if default_options.empty? module_eval(<<-EOS, __FILE__, __LINE__ + 1) def #{name}( *args, &block ) super( *rake_merge_option(args, #{default_options.join(', ')} ), &block) end EOS end # Get/set the verbose flag controlling output from the FileUtils # utilities. If verbose is true, then the utility method is # echoed to standard output. # # Examples: # verbose # return the current value of the # # verbose flag # verbose(v) # set the verbose flag to _v_. # verbose(v) { code } # Execute code with the verbose flag set # # temporarily to _v_. Return to the # # original value when code is done. def verbose(value=nil) oldvalue = FileUtilsExt.verbose_flag FileUtilsExt.verbose_flag = value unless value.nil? if block_given? begin yield ensure FileUtilsExt.verbose_flag = oldvalue end end FileUtilsExt.verbose_flag end # Get/set the nowrite flag controlling output from the FileUtils # utilities. If verbose is true, then the utility method is # echoed to standard output. # # Examples: # nowrite # return the current value of the # # nowrite flag # nowrite(v) # set the nowrite flag to _v_. # nowrite(v) { code } # Execute code with the nowrite flag set # # temporarily to _v_. Return to the # # original value when code is done. def nowrite(value=nil) oldvalue = FileUtilsExt.nowrite_flag FileUtilsExt.nowrite_flag = value unless value.nil? if block_given? begin yield ensure FileUtilsExt.nowrite_flag = oldvalue end end oldvalue end # Use this function to prevent potentially destructive ruby code # from running when the :nowrite flag is set. # # Example: # # when_writing("Building Project") do # project.build # end # # The following code will build the project under normal # conditions. If the nowrite(true) flag is set, then the example # will print: # # DRYRUN: Building Project # # instead of actually building the project. # def when_writing(msg=nil) if FileUtilsExt.nowrite_flag $stderr.puts "DRYRUN: #{msg}" if msg else yield end end # Merge the given options with the default values. def rake_merge_option(args, defaults) if Hash === args.last defaults.update(args.last) args.pop end args.push defaults args end # Send the message to the default rake output (which is $stderr). def rake_output_message(message) $stderr.puts(message) end # Check that the options do not contain options not listed in # +optdecl+. An ArgumentError exception is thrown if non-declared # options are found. def rake_check_options(options, *optdecl) h = options.dup optdecl.each do |name| h.delete name end raise ArgumentError, "no such option: #{h.keys.join(' ')}" unless h.empty? end extend self end end rake-10.0.4/lib/rake/file_utils.rb0000644000004100000410000000601612124115317016722 0ustar www-datawww-datarequire 'rbconfig' require 'fileutils' #-- # This a FileUtils extension that defines several additional commands to be # added to the FileUtils utility functions. module FileUtils # Path to the currently running Ruby program RUBY = ENV['RUBY'] || File.join( RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'] + RbConfig::CONFIG['EXEEXT']). sub(/.*\s.*/m, '"\&"') OPT_TABLE['sh'] = %w(noop verbose) OPT_TABLE['ruby'] = %w(noop verbose) # Run the system command +cmd+. If multiple arguments are given the command # is not run with the shell (same semantics as Kernel::exec and # Kernel::system). # # Example: # sh %{ls -ltr} # # sh 'ls', 'file with spaces' # # # check exit status after command runs # sh %{grep pattern file} do |ok, res| # if ! ok # puts "pattern not found (status = #{res.exitstatus})" # end # end # def sh(*cmd, &block) options = (Hash === cmd.last) ? cmd.pop : {} shell_runner = block_given? ? block : create_shell_runner(cmd) set_verbose_option(options) options[:noop] ||= Rake::FileUtilsExt.nowrite_flag Rake.rake_check_options options, :noop, :verbose Rake.rake_output_message cmd.join(" ") if options[:verbose] unless options[:noop] res = rake_system(*cmd) status = $? status = Rake::PseudoStatus.new(1) if !res && status.nil? shell_runner.call(res, status) end end def create_shell_runner(cmd) # :nodoc: show_command = cmd.join(" ") show_command = show_command[0,42] + "..." unless $trace lambda { |ok, status| ok or fail "Command failed with status (#{status.exitstatus}): [#{show_command}]" } end private :create_shell_runner def set_verbose_option(options) # :nodoc: unless options.key? :verbose options[:verbose] = (Rake::FileUtilsExt.verbose_flag == Rake::FileUtilsExt::DEFAULT) || Rake::FileUtilsExt.verbose_flag end end private :set_verbose_option def rake_system(*cmd) # :nodoc: Rake::AltSystem.system(*cmd) end private :rake_system # Run a Ruby interpreter with the given arguments. # # Example: # ruby %{-pe '$_.upcase!' 1 then sh(*([RUBY] + args + [options]), &block) else sh("#{RUBY} #{args.first}", options, &block) end end LN_SUPPORTED = [true] # Attempt to do a normal file link, but fall back to a copy if the link # fails. def safe_ln(*args) unless LN_SUPPORTED[0] cp(*args) else begin ln(*args) rescue StandardError, NotImplementedError LN_SUPPORTED[0] = false cp(*args) end end end # Split a file path into individual directory names. # # Example: # split_all("a/b/c") => ['a', 'b', 'c'] # def split_all(path) head, tail = File.split(path) return [tail] if head == '.' || tail == '/' return [head, tail] if head == '/' return split_all(head) + [tail] end end rake-10.0.4/lib/rake/thread_pool.rb0000644000004100000410000001125412124115317017063 0ustar www-datawww-datarequire 'thread' require 'set' require 'rake/promise' module Rake class ThreadPool # :nodoc: all # Creates a ThreadPool object. # The parameter is the size of the pool. def initialize(thread_count) @max_active_threads = [thread_count, 0].max @threads = Set.new @threads_mon = Monitor.new @queue = Queue.new @join_cond = @threads_mon.new_cond @history_start_time = nil @history = [] @history_mon = Monitor.new @total_threads_in_play = 0 end # Creates a future executed by the +ThreadPool+. # # The args are passed to the block when executing (similarly to # Thread#new) The return value is an object representing # a future which has been created and added to the queue in the # pool. Sending #value to the object will sleep the # current thread until the future is finished and will return the # result (or raise an exception thrown from the future) def future(*args, &block) promise = Promise.new(args, &block) promise.recorder = lambda { |*stats| stat(*stats) } @queue.enq promise stat :queued, :item_id => promise.object_id start_thread promise end # Waits until the queue of futures is empty and all threads have exited. def join @threads_mon.synchronize do begin stat :joining @join_cond.wait unless @threads.empty? stat :joined rescue Exception => e stat :joined $stderr.puts e $stderr.print "Queue contains #{@queue.size} items. Thread pool contains #{@threads.count} threads\n" $stderr.print "Current Thread #{Thread.current} status = #{Thread.current.status}\n" $stderr.puts e.backtrace.join("\n") @threads.each do |t| $stderr.print "Thread #{t} status = #{t.status}\n" # 1.8 doesn't support Thread#backtrace $stderr.puts t.backtrace.join("\n") if t.respond_to? :backtrace end raise e end end end # Enable the gathering of history events. def gather_history #:nodoc: @history_start_time = Time.now if @history_start_time.nil? end # Return a array of history events for the thread pool. # # History gathering must be enabled to be able to see the events # (see #gather_history). Best to call this when the job is # complete (i.e. after ThreadPool#join is called). def history # :nodoc: @history_mon.synchronize { @history.dup }. sort_by { |i| i[:time] }. each { |i| i[:time] -= @history_start_time } end # Return a hash of always collected statistics for the thread pool. def statistics # :nodoc: { :total_threads_in_play => @total_threads_in_play, :max_active_threads => @max_active_threads, } end private # processes one item on the queue. Returns true if there was an # item to process, false if there was no item def process_queue_item #:nodoc: return false if @queue.empty? # Even though we just asked if the queue was empty, it # still could have had an item which by this statement # is now gone. For this reason we pass true to Queue#deq # because we will sleep indefinitely if it is empty. promise = @queue.deq(true) stat :dequeued, :item_id => promise.object_id promise.work return true rescue ThreadError # this means the queue is empty false end def start_thread # :nodoc: @threads_mon.synchronize do next unless @threads.count < @max_active_threads t = Thread.new do begin while @threads.count <= @max_active_threads break unless process_queue_item end ensure @threads_mon.synchronize do @threads.delete Thread.current stat :ended, :thread_count => @threads.count @join_cond.broadcast if @threads.empty? end end end @threads << t stat :spawned, :new_thread => t.object_id, :thread_count => @threads.count @total_threads_in_play = @threads.count if @threads.count > @total_threads_in_play end end def stat(event, data=nil) # :nodoc: return if @history_start_time.nil? info = { :event => event, :data => data, :time => Time.now, :thread => Thread.current.object_id, } @history_mon.synchronize { @history << info } end # for testing only def __queue__ # :nodoc: @queue end def __threads__ # :nodoc: @threads.dup end end end rake-10.0.4/lib/rake/thread_history_display.rb0000644000004100000410000000215112124115317021334 0ustar www-datawww-datarequire 'rake/private_reader' module Rake class ThreadHistoryDisplay # :nodoc: all include Rake::PrivateReader private_reader :stats, :items, :threads def initialize(stats) @stats = stats @items = { :_seq_ => 1 } @threads = { :_seq_ => "A" } end def show puts "Job History:" stats.each do |stat| stat[:data] ||= {} rename(stat, :thread, threads) rename(stat[:data], :item_id, items) rename(stat[:data], :new_thread, threads) rename(stat[:data], :deleted_thread, threads) printf("%8d %2s %-20s %s\n", (stat[:time] * 1_000_000).round, stat[:thread], stat[:event], stat[:data].map { |k,v| "#{k}:#{v}" }.join(" ")) end end private def rename(hash, key, renames) if hash && hash[key] original = hash[key] value = renames[original] unless value value = renames[:_seq_] renames[:_seq_] = renames[:_seq_].succ renames[original] = value end hash[key] = value end end end end rake-10.0.4/lib/rake/trace_output.rb0000644000004100000410000000102112124115317017270 0ustar www-datawww-datamodule Rake module TraceOutput # Write trace output to output stream +out+. # # The write is done as a single IO call (to print) to lessen the # chance that the trace output is interrupted by other tasks also # producing output. def trace_on(out, *strings) sep = $\ || "\n" if strings.empty? output = sep else output = strings.map { |s| next if s.nil? s =~ /#{sep}$/ ? s : s + sep }.join end out.print(output) end end end rake-10.0.4/lib/rake/rake_test_loader.rb0000644000004100000410000000052512124115317020071 0ustar www-datawww-datarequire 'rake' # Load the test files from the command line. argv = ARGV.select do |argument| case argument when /^-/ then argument when /\*/ then FileList[argument].to_a.each do |file| require File.expand_path file end false else require File.expand_path argument false end end ARGV.replace argv rake-10.0.4/lib/rake/clean.rb0000644000004100000410000000200112124115317015633 0ustar www-datawww-data# The 'rake/clean' file defines two file lists (CLEAN and CLOBBER) and # two rake tasks (:clean and :clobber). # # [:clean] Clean up the project by deleting scratch files and backup # files. Add files to the CLEAN file list to have the :clean # target handle them. # # [:clobber] Clobber all generated and non-source files in a project. # The task depends on :clean, so all the clean files will # be deleted as well as files in the CLOBBER file list. # The intent of this task is to return a project to its # pristine, just unpacked state. require 'rake' # :stopdoc: CLEAN = Rake::FileList["**/*~", "**/*.bak", "**/core"] CLEAN.clear_exclude.exclude { |fn| fn.pathmap("%f").downcase == 'core' && File.directory?(fn) } desc "Remove any temporary products." task :clean do CLEAN.each { |fn| rm_r fn rescue nil } end CLOBBER = Rake::FileList.new desc "Remove any generated file." task :clobber => [:clean] do CLOBBER.each { |fn| rm_r fn rescue nil } end rake-10.0.4/lib/rake/ruby182_test_unit_fix.rb0000644000004100000410000000151312124115317020740 0ustar www-datawww-data# Local Rake override to fix bug in Ruby 0.8.2 module Test # :nodoc: # Local Rake override to fix bug in Ruby 0.8.2 module Unit # :nodoc: # Local Rake override to fix bug in Ruby 0.8.2 module Collector # :nodoc: # Local Rake override to fix bug in Ruby 0.8.2 class Dir # :nodoc: undef collect_file def collect_file(name, suites, already_gathered) # :nodoc: dir = File.dirname(File.expand_path(name)) $:.unshift(dir) unless $:.first == dir if(@req) @req.require(name) else require(name) end find_test_cases(already_gathered).each{|t| add_suite(suites, t.suite)} ensure $:.delete_at $:.rindex(dir) end end end end end rake-10.0.4/lib/rake/invocation_chain.rb0000644000004100000410000000170212124115317020073 0ustar www-datawww-datamodule Rake #################################################################### # InvocationChain tracks the chain of task invocations to detect # circular dependencies. class InvocationChain def initialize(value, tail) @value = value @tail = tail end def member?(obj) @value == obj || @tail.member?(obj) end def append(value) if member?(value) fail RuntimeError, "Circular dependency detected: #{to_s} => #{value}" end self.class.new(value, self) end def to_s "#{prefix}#{@value}" end def self.append(value, chain) chain.append(value) end private def prefix "#{@tail.to_s} => " end class EmptyInvocationChain def member?(obj) false end def append(value) InvocationChain.new(value, self) end def to_s "TOP" end end EMPTY = EmptyInvocationChain.new end end rake-10.0.4/lib/rake/testtask.rb0000644000004100000410000001227212124115317016426 0ustar www-datawww-data# Define a task library for running unit tests. require 'rake' require 'rake/tasklib' module Rake # Create a task that runs a set of tests. # # Example: # # Rake::TestTask.new do |t| # t.libs << "test" # t.test_files = FileList['test/test*.rb'] # t.verbose = true # end # # If rake is invoked with a "TEST=filename" command line option, # then the list of test files will be overridden to include only the # filename specified on the command line. This provides an easy way # to run just one test. # # If rake is invoked with a "TESTOPTS=options" command line option, # then the given options are passed to the test process after a # '--'. This allows Test::Unit options to be passed to the test # suite. # # Examples: # # rake test # run tests normally # rake test TEST=just_one_file.rb # run just one test file. # rake test TESTOPTS="-v" # run in verbose mode # rake test TESTOPTS="--runner=fox" # use the fox test runner # class TestTask < TaskLib # Name of test task. (default is :test) attr_accessor :name # List of directories to added to $LOAD_PATH before running the # tests. (default is 'lib') attr_accessor :libs # True if verbose test output desired. (default is false) attr_accessor :verbose # Test options passed to the test suite. An explicit # TESTOPTS=opts on the command line will override this. (default # is NONE) attr_accessor :options # Request that the tests be run with the warning flag set. # E.g. warning=true implies "ruby -w" used to run the tests. attr_accessor :warning # Glob pattern to match test files. (default is 'test/test*.rb') attr_accessor :pattern # Style of test loader to use. Options are: # # * :rake -- Rake provided test loading script (default). # * :testrb -- Ruby provided test loading script. # * :direct -- Load tests using command line loader. # attr_accessor :loader # Array of commandline options to pass to ruby when running test loader. attr_accessor :ruby_opts # Explicitly define the list of test files to be included in a # test. +list+ is expected to be an array of file names (a # FileList is acceptable). If both +pattern+ and +test_files+ are # used, then the list of test files is the union of the two. def test_files=(list) @test_files = list end # Create a testing task. def initialize(name=:test) @name = name @libs = ["lib"] @pattern = nil @options = nil @test_files = nil @verbose = false @warning = false @loader = :rake @ruby_opts = [] yield self if block_given? @pattern = 'test/test*.rb' if @pattern.nil? && @test_files.nil? define end # Create the tasks defined by this task lib. def define desc "Run tests" + (@name==:test ? "" : " for #{@name}") task @name do FileUtilsExt.verbose(@verbose) do args = "#{ruby_opts_string} #{run_code} #{file_list_string} #{option_list}" ruby args do |ok, status| if !ok && status.respond_to?(:signaled?) && status.signaled? raise SignalException.new(status.termsig) elsif !ok fail "Command failed with status (#{status.exitstatus}): [ruby #{args}]" end end end end self end def option_list # :nodoc: (ENV['TESTOPTS'] || ENV['TESTOPT'] || ENV['TEST_OPTS'] || ENV['TEST_OPT'] || @options || "") end def ruby_opts_string opts = @ruby_opts.dup opts.unshift( "-I\"#{lib_path}\"" ) unless @libs.empty? opts.unshift( "-w" ) if @warning opts.join(" ") end def lib_path @libs.join(File::PATH_SEPARATOR) end def file_list_string file_list.collect { |fn| "\"#{fn}\"" }.join(' ') end def file_list # :nodoc: if ENV['TEST'] FileList[ ENV['TEST'] ] else result = [] result += @test_files.to_a if @test_files result << @pattern if @pattern result end end def fix # :nodoc: case ruby_version when '1.8.2' "\"#{find_file 'rake/ruby182_test_unit_fix'}\"" else nil end || '' end def ruby_version RUBY_VERSION end def run_code case @loader when :direct "-e \"ARGV.each{|f| require f}\"" when :testrb "-S testrb #{fix}" when :rake "-I\"#{rake_lib_dir}\" \"#{rake_loader}\"" end end def rake_loader # :nodoc: find_file('rake/rake_test_loader') or fail "unable to find rake test loader" end def find_file(fn) # :nodoc: $LOAD_PATH.each do |path| file_path = File.join(path, "#{fn}.rb") return file_path if File.exist? file_path end nil end def rake_lib_dir # :nodoc: find_dir('rake') or fail "unable to find rake lib" end def find_dir(fn) # :nodoc: $LOAD_PATH.each do |path| file_path = File.join(path, "#{fn}.rb") return path if File.exist? file_path end nil end end end rake-10.0.4/lib/rake/tasklib.rb0000644000004100000410000000110412124115317016205 0ustar www-datawww-datarequire 'rake' module Rake # Base class for Task Libraries. class TaskLib include Cloneable include Rake::DSL # Make a symbol by pasting two strings together. # # NOTE: DEPRECATED! This method is kinda stupid. I don't know why # I didn't just use string interpolation. But now other task # libraries depend on this so I can't remove it without breaking # other people's code. So for now it stays for backwards # compatibility. BUT DON'T USE IT. def paste(a,b) # :nodoc: (a.to_s + b.to_s).intern end end end rake-10.0.4/lib/rake/rdoctask.rb0000644000004100000410000000016712124115317016376 0ustar www-datawww-datafail "ERROR: 'rake/rdoctask' is obsolete and no longer supported. Use 'rdoc/task' (available in RDoc 2.4.2+) instead." rake-10.0.4/lib/rake/dsl_definition.rb0000644000004100000410000001014712124115317017555 0ustar www-datawww-data# Rake DSL functions. require 'rake/file_utils_ext' module Rake ## # DSL is a module that provides #task, #desc, #namespace, etc. Use this # when you'd like to use rake outside the top level scope. module DSL #-- # Include the FileUtils file manipulation functions in the top # level module, but mark them private so that they don't # unintentionally define methods on other objects. #++ include FileUtilsExt private(*FileUtils.instance_methods(false)) private(*FileUtilsExt.instance_methods(false)) private # Declare a basic task. # # Example: # task :clobber => [:clean] do # rm_rf "html" # end # def task(*args, &block) Rake::Task.define_task(*args, &block) end # Declare a file task. # # Example: # file "config.cfg" => ["config.template"] do # open("config.cfg", "w") do |outfile| # open("config.template") do |infile| # while line = infile.gets # outfile.puts line # end # end # end # end # def file(*args, &block) Rake::FileTask.define_task(*args, &block) end # Declare a file creation task. # (Mainly used for the directory command). def file_create(*args, &block) Rake::FileCreationTask.define_task(*args, &block) end # Declare a set of files tasks to create the given directories on # demand. # # Example: # directory "testdata/doc" # def directory(*args, &block) result = file_create(*args, &block) dir, _ = *Rake.application.resolve_args(args) Rake.each_dir_parent(dir) do |d| file_create d do |t| mkdir_p t.name if ! File.exist?(t.name) end end result end # Declare a task that performs its prerequisites in # parallel. Multitasks does *not* guarantee that its prerequisites # will execute in any given order (which is obvious when you think # about it) # # Example: # multitask :deploy => [:deploy_gem, :deploy_rdoc] # def multitask(*args, &block) Rake::MultiTask.define_task(*args, &block) end # Create a new rake namespace and use it for evaluating the given # block. Returns a NameSpace object that can be used to lookup # tasks defined in the namespace. # # E.g. # # ns = namespace "nested" do # task :run # end # task_run = ns[:run] # find :run in the given namespace. # def namespace(name=nil, &block) name = name.to_s if name.kind_of?(Symbol) name = name.to_str if name.respond_to?(:to_str) unless name.kind_of?(String) || name.nil? raise ArgumentError, "Expected a String or Symbol for a namespace name" end Rake.application.in_namespace(name, &block) end # Declare a rule for auto-tasks. # # Example: # rule '.o' => '.c' do |t| # sh %{cc -o #{t.name} #{t.source}} # end # def rule(*args, &block) Rake::Task.create_rule(*args, &block) end # Describe the next rake task. # # Example: # desc "Run the Unit Tests" # task :test => [:build] # runtests # end # def desc(description) Rake.application.last_description = description end # Import the partial Rakefiles +fn+. Imported files are loaded # _after_ the current file is completely loaded. This allows the # import statement to appear anywhere in the importing file, and yet # allowing the imported files to depend on objects defined in the # importing file. # # A common use of the import statement is to include files # containing dependency declarations. # # See also the --rakelibdir command line option. # # Example: # import ".depend", "my_rules" # def import(*fns) fns.each do |fn| Rake.application.add_import(fn) end end end extend FileUtilsExt end # Extend the main object with the DSL commands. This allows top-level # calls to task, etc. to work from a Rakefile without polluting the # object inheritance tree. self.extend Rake::DSL rake-10.0.4/lib/rake/pathmap.rb0000644000004100000410000000003212124115317016205 0ustar www-datawww-datarequire 'rake/ext/string' rake-10.0.4/lib/rake/packagetask.rb0000644000004100000410000001210712124115317017037 0ustar www-datawww-data# Define a package task library to aid in the definition of # redistributable package files. require 'rake' require 'rake/tasklib' module Rake # Create a packaging task that will package the project into # distributable files (e.g zip archive or tar files). # # The PackageTask will create the following targets: # # [:package] # Create all the requested package files. # # [:clobber_package] # Delete all the package files. This target is automatically # added to the main clobber target. # # [:repackage] # Rebuild the package files from scratch, even if they are not out # of date. # # ["package_dir/name-version.tgz"] # Create a gzipped tar package (if need_tar is true). # # ["package_dir/name-version.tar.gz"] # Create a gzipped tar package (if need_tar_gz is true). # # ["package_dir/name-version.tar.bz2"] # Create a bzip2'd tar package (if need_tar_bz2 is true). # # ["package_dir/name-version.zip"] # Create a zip package archive (if need_zip is true). # # Example: # # Rake::PackageTask.new("rake", "1.2.3") do |p| # p.need_tar = true # p.package_files.include("lib/**/*.rb") # end # class PackageTask < TaskLib # Name of the package (from the GEM Spec). attr_accessor :name # Version of the package (e.g. '1.3.2'). attr_accessor :version # Directory used to store the package files (default is 'pkg'). attr_accessor :package_dir # True if a gzipped tar file (tgz) should be produced (default is false). attr_accessor :need_tar # True if a gzipped tar file (tar.gz) should be produced (default is false). attr_accessor :need_tar_gz # True if a bzip2'd tar file (tar.bz2) should be produced (default is false). attr_accessor :need_tar_bz2 # True if a zip file should be produced (default is false) attr_accessor :need_zip # List of files to be included in the package. attr_accessor :package_files # Tar command for gzipped or bzip2ed archives. The default is 'tar'. attr_accessor :tar_command # Zip command for zipped archives. The default is 'zip'. attr_accessor :zip_command # Create a Package Task with the given name and version. Use +:noversion+ # as the version to build a package without a version or to provide a # fully-versioned package name. def initialize(name=nil, version=nil) init(name, version) yield self if block_given? define unless name.nil? end # Initialization that bypasses the "yield self" and "define" step. def init(name, version) @name = name @version = version @package_files = Rake::FileList.new @package_dir = 'pkg' @need_tar = false @need_tar_gz = false @need_tar_bz2 = false @need_zip = false @tar_command = 'tar' @zip_command = 'zip' end # Create the tasks defined by this task library. def define fail "Version required (or :noversion)" if @version.nil? @version = nil if :noversion == @version desc "Build all the packages" task :package desc "Force a rebuild of the package files" task :repackage => [:clobber_package, :package] desc "Remove package products" task :clobber_package do rm_r package_dir rescue nil end task :clobber => [:clobber_package] [ [need_tar, tgz_file, "z"], [need_tar_gz, tar_gz_file, "z"], [need_tar_bz2, tar_bz2_file, "j"] ].each do |(need, file, flag)| if need task :package => ["#{package_dir}/#{file}"] file "#{package_dir}/#{file}" => [package_dir_path] + package_files do chdir(package_dir) do sh %{#{@tar_command} #{flag}cvf #{file} #{package_name}} end end end end if need_zip task :package => ["#{package_dir}/#{zip_file}"] file "#{package_dir}/#{zip_file}" => [package_dir_path] + package_files do chdir(package_dir) do sh %{#{@zip_command} -r #{zip_file} #{package_name}} end end end directory package_dir file package_dir_path => @package_files do mkdir_p package_dir rescue nil @package_files.each do |fn| f = File.join(package_dir_path, fn) fdir = File.dirname(f) mkdir_p(fdir) if !File.exist?(fdir) if File.directory?(fn) mkdir_p(f) else rm_f f safe_ln(fn, f) end end end self end def package_name @version ? "#{@name}-#{@version}" : @name end def package_dir_path "#{package_dir}/#{package_name}" end def tgz_file "#{package_name}.tgz" end def tar_gz_file "#{package_name}.tar.gz" end def tar_bz2_file "#{package_name}.tar.bz2" end def zip_file "#{package_name}.zip" end end end rake-10.0.4/lib/rake/default_loader.rb0000644000004100000410000000024412124115317017532 0ustar www-datawww-datamodule Rake # Default Rakefile loader used by +import+. class DefaultLoader def load(fn) Rake.load_rakefile(File.expand_path(fn)) end end end rake-10.0.4/lib/rake/task_manager.rb0000644000004100000410000002054112124115317017216 0ustar www-datawww-datamodule Rake # The TaskManager module is a mixin for managing tasks. module TaskManager # Track the last comment made in the Rakefile. attr_accessor :last_description alias :last_comment :last_description # Backwards compatibility def initialize super @tasks = Hash.new @rules = Array.new @scope = Array.new @last_description = nil end def create_rule(*args, &block) pattern, _, deps = resolve_args(args) pattern = Regexp.new(Regexp.quote(pattern) + '$') if String === pattern @rules << [pattern, deps, block] end def define_task(task_class, *args, &block) task_name, arg_names, deps = resolve_args(args) task_name = task_class.scope_name(@scope, task_name) deps = [deps] unless deps.respond_to?(:to_ary) deps = deps.collect {|d| d.to_s } task = intern(task_class, task_name) task.set_arg_names(arg_names) unless arg_names.empty? if Rake::TaskManager.record_task_metadata add_location(task) task.add_description(get_description(task)) end task.enhance(deps, &block) end # Lookup a task. Return an existing task if found, otherwise # create a task of the current type. def intern(task_class, task_name) @tasks[task_name.to_s] ||= task_class.new(task_name, self) end # Find a matching task for +task_name+. def [](task_name, scopes=nil) task_name = task_name.to_s self.lookup(task_name, scopes) or enhance_with_matching_rule(task_name) or synthesize_file_task(task_name) or fail "Don't know how to build task '#{task_name}'" end def synthesize_file_task(task_name) return nil unless File.exist?(task_name) define_task(Rake::FileTask, task_name) end # Resolve the arguments for a task/rule. Returns a triplet of # [task_name, arg_name_list, prerequisites]. def resolve_args(args) if args.last.is_a?(Hash) deps = args.pop resolve_args_with_dependencies(args, deps) else resolve_args_without_dependencies(args) end end # Resolve task arguments for a task or rule when there are no # dependencies declared. # # The patterns recognized by this argument resolving function are: # # task :t # task :t, [:a] # def resolve_args_without_dependencies(args) task_name = args.shift if args.size == 1 && args.first.respond_to?(:to_ary) arg_names = args.first.to_ary else arg_names = args end [task_name, arg_names, []] end private :resolve_args_without_dependencies # Resolve task arguments for a task or rule when there are # dependencies declared. # # The patterns recognized by this argument resolving function are: # # task :t => [:d] # task :t, [a] => [:d] # def resolve_args_with_dependencies(args, hash) # :nodoc: fail "Task Argument Error" if hash.size != 1 key, value = hash.map { |k, v| [k,v] }.first if args.empty? task_name = key arg_names = [] deps = value else task_name = args.shift arg_names = key deps = value end deps = [deps] unless deps.respond_to?(:to_ary) [task_name, arg_names, deps] end private :resolve_args_with_dependencies # If a rule can be found that matches the task name, enhance the # task with the prerequisites and actions from the rule. Set the # source attribute of the task appropriately for the rule. Return # the enhanced task or nil of no rule was found. def enhance_with_matching_rule(task_name, level=0) fail Rake::RuleRecursionOverflowError, "Rule Recursion Too Deep" if level >= 16 @rules.each do |pattern, extensions, block| if pattern.match(task_name) task = attempt_rule(task_name, extensions, block, level) return task if task end end nil rescue Rake::RuleRecursionOverflowError => ex ex.add_target(task_name) fail ex end # List of all defined tasks in this application. def tasks @tasks.values.sort_by { |t| t.name } end # List of all the tasks defined in the given scope (and its # sub-scopes). def tasks_in_scope(scope) prefix = scope.join(":") tasks.select { |t| /^#{prefix}:/ =~ t.name } end # Clear all tasks in this application. def clear @tasks.clear @rules.clear end # Lookup a task, using scope and the scope hints in the task name. # This method performs straight lookups without trying to # synthesize file tasks or rules. Special scope names (e.g. '^') # are recognized. If no scope argument is supplied, use the # current scope. Return nil if the task cannot be found. def lookup(task_name, initial_scope=nil) initial_scope ||= @scope task_name = task_name.to_s if task_name =~ /^rake:/ scopes = [] task_name = task_name.sub(/^rake:/, '') elsif task_name =~ /^(\^+)/ scopes = initial_scope[0, initial_scope.size - $1.size] task_name = task_name.sub(/^(\^+)/, '') else scopes = initial_scope end lookup_in_scope(task_name, scopes) end # Lookup the task name def lookup_in_scope(name, scope) n = scope.size while n >= 0 tn = (scope[0,n] + [name]).join(':') task = @tasks[tn] return task if task n -= 1 end nil end private :lookup_in_scope # Return the list of scope names currently active in the task # manager. def current_scope @scope.dup end # Evaluate the block in a nested namespace named +name+. Create # an anonymous namespace if +name+ is nil. def in_namespace(name) name ||= generate_name @scope.push(name) ns = NameSpace.new(self, @scope) yield(ns) ns ensure @scope.pop end private # Add a location to the locations field of the given task. def add_location(task) loc = find_location task.locations << loc if loc task end # Find the location that called into the dsl layer. def find_location locations = caller i = 0 while locations[i] return locations[i+1] if locations[i] =~ /rake\/dsl_definition.rb/ i += 1 end nil end # Generate an anonymous namespace name. def generate_name @seed ||= 0 @seed += 1 "_anon_#{@seed}" end def trace_rule(level, message) options.trace_output.puts "#{" "*level}#{message}" if Rake.application.options.trace_rules end # Attempt to create a rule given the list of prerequisites. def attempt_rule(task_name, extensions, block, level) sources = make_sources(task_name, extensions) prereqs = sources.collect { |source| trace_rule level, "Attempting Rule #{task_name} => #{source}" if File.exist?(source) || Rake::Task.task_defined?(source) trace_rule level, "(#{task_name} => #{source} ... EXIST)" source elsif parent = enhance_with_matching_rule(source, level+1) trace_rule level, "(#{task_name} => #{source} ... ENHANCE)" parent.name else trace_rule level, "(#{task_name} => #{source} ... FAIL)" return nil end } task = FileTask.define_task({task_name => prereqs}, &block) task.sources = prereqs task end # Make a list of sources from the list of file name extensions / # translation procs. def make_sources(task_name, extensions) result = extensions.collect { |ext| case ext when /%/ task_name.pathmap(ext) when %r{/} ext when /^\./ task_name.ext(ext) when String ext when Proc if ext.arity == 1 ext.call(task_name) else ext.call end else fail "Don't know how to handle rule dependent: #{ext.inspect}" end } result.flatten end private # Return the current description, clearing it in the process. def get_description(task) desc = @last_description @last_description = nil desc end class << self attr_accessor :record_task_metadata TaskManager.record_task_metadata = false end end end