rake 10.0.4 → 10.1.0.beta.1

data/test/test_rake_task_arguments.rb

@@ -26,8 +26,8 @@ class TestRakeTaskArguments < Rake::TestCase
   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
+    ta = Rake::TaskArguments.new([:a, :b, :c], [1, 2, 3])
+    assert_equal [10, 20, 30], ta.map { |k, v| v * 10 }.sort
   end
 
   def test_named_args
@@ -85,4 +85,37 @@ class TestRakeTaskArguments < Rake::TestCase
     ta.with_defaults({ "cc" => "default_val" })
     assert_nil ta[:cc]
   end
+
+  def test_all_and_extra_arguments_without_named_arguments
+    app = Rake::Application.new
+    _, args = app.parse_task_string("task[1,two,more]")
+    ta = Rake::TaskArguments.new([], args)
+    assert_equal [], ta.names
+    assert_equal ['1', 'two', 'more'], ta.to_a
+    assert_equal ['1', 'two', 'more'], ta.extras
+  end
+
+  def test_all_and_extra_arguments_with_named_arguments
+    app = Rake::Application.new
+    _, args = app.parse_task_string("task[1,two,more,still more]")
+    ta = Rake::TaskArguments.new([:first, :second], args)
+    assert_equal [:first, :second], ta.names
+    assert_equal "1", ta[:first]
+    assert_equal "two", ta[:second]
+    assert_equal ['1', 'two', 'more', 'still more'], ta.to_a
+    assert_equal ['more', 'still more'], ta.extras
+  end
+
+  def test_extra_args_with_less_than_named_arguments
+    app = Rake::Application.new
+    _, args = app.parse_task_string("task[1,two]")
+    ta = Rake::TaskArguments.new([:first, :second, :third], args)
+    assert_equal [:first, :second, :third], ta.names
+    assert_equal "1", ta[:first]
+    assert_equal "two", ta[:second]
+    assert_equal nil, ta[:third]
+    assert_equal ['1', 'two'], ta.to_a
+    assert_equal [], ta.extras
+  end
+
 end

data/test/test_rake_task_manager.rb

@@ -37,7 +37,7 @@ class TestRakeTaskManager < Rake::TestCase
       t = @tm.define_task(Rake::Task, :t)
       assert_equal "x:t", t.name
     end
-    assert_equal ["x:t"], @tm.tasks.collect { |t| t.name }
+    assert_equal ["x:t"], @tm.tasks.map { |t| t.name }
   end
 
   def test_anonymous_namespace
@@ -55,7 +55,7 @@ class TestRakeTaskManager < Rake::TestCase
       assert_equal "fn", t.name
     end
 
-    assert_equal ["fn"], @tm.tasks.collect { |t| t.name }
+    assert_equal ["fn"], @tm.tasks.map { |t| t.name }
   end
 
   def test_namespace_yields_same_namespace_as_returned
@@ -124,7 +124,7 @@ class TestRakeTaskManager < Rake::TestCase
   end
 
   def test_lookup_with_explicit_scopes
-    t1, t2, t3, s = (0...4).collect { nil }
+    t1, t2, t3, s = (0...4).map { nil }
     t1 = @tm.define_task(Rake::Task, :t)
     @tm.in_namespace("a") do
       t2 = @tm.define_task(Rake::Task, :t)
@@ -154,4 +154,3 @@ class TestRakeTaskManager < Rake::TestCase
   end
 
 end
-

data/test/test_rake_task_with_arguments.rb

@@ -81,7 +81,7 @@ class TestRakeTaskWithArguments < Rake::TestCase
 
   def test_arguments_are_passed_to_block
     t = task(:t, :a, :b) { |tt, args|
-      assert_equal( { :a => 1, :b => 2 }, args.to_hash )
+      assert_equal({ :a => 1, :b => 2 }, args.to_hash)
     }
     t.invoke(1, 2)
   end
@@ -121,7 +121,7 @@ class TestRakeTaskWithArguments < Rake::TestCase
     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
+    assert_equal [:a, :b], t.arg_names
   end
 
   def test_named_args_are_passed_to_prereqs

data/test/test_rake_test_task.rb

@@ -28,7 +28,7 @@ class TestRakeTestTask < Rake::TestCase
     assert Task.task_defined?(:example)
   end
 
-  def test_file_list_ENV_TEST
+  def test_file_list_env_test
     ENV['TEST'] = 'testfile.rb'
     tt = Rake::TestTask.new do |t|
       t.pattern = '*'
@@ -117,4 +117,3 @@ class TestRakeTestTask < Rake::TestCase
   end
 
 end
-

data/test/test_rake_thread_pool.rb

@@ -7,21 +7,28 @@ class TestRakeTestThreadPool < Rake::TestCase
 
   def test_pool_executes_in_current_thread_for_zero_threads
     pool = ThreadPool.new(0)
-    f = pool.future{Thread.current}
+    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}
+    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}
+    threads = 2.times.map {
+      pool.future {
+        sleep 0.1
+        Thread.current
+      }
+    }.each { |f|
+      f.value
+    }
 
     refute_equal threads[0], threads[1]
     refute_equal Thread.current, threads[0]
@@ -35,14 +42,14 @@ class TestRakeTestThreadPool < Rake::TestCase
     10.times.each do
       pool.future do
         sleep 0.02
-        t_mutex.synchronize{ threads << Thread.current }
+        t_mutex.synchronize { threads << Thread.current }
       end
     end
     pool.join
     assert_equal 2, threads.count
   end
 
-  def test_pool_future_does_NOT_duplicate_arguments
+  def test_pool_future_does_not_duplicate_arguments
     pool = ThreadPool.new(2)
     obj = Object.new
     captured = nil
@@ -67,7 +74,10 @@ class TestRakeTestThreadPool < Rake::TestCase
     }
 
     pool.join
-    assert_equal true, pool.__send__(:__queue__).empty?, "queue should be empty"
+    assert_equal(
+      true,
+      pool.__send__(:__queue__).empty?,
+      "queue should be empty")
   end
 
   CustomError = Class.new(StandardError)
@@ -78,8 +88,8 @@ class TestRakeTestThreadPool < Rake::TestCase
     pool = ThreadPool.new(10)
 
     deep_exception_block = lambda do |count|
-      raise CustomError if ( count < 1 )
-      pool.future(count-1, &deep_exception_block).value
+      raise CustomError if count < 1
+      pool.future(count - 1, &deep_exception_block).value
     end
 
     assert_raises(CustomError) do
@@ -91,12 +101,22 @@ class TestRakeTestThreadPool < Rake::TestCase
     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) } }
+    futures_a = 10.times.map {
+      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 = 10.times.map {
+      pool.future {
+        common_dependency_b.value
+        sleep(rand() * 0.01)
+      }
+    }
 
-    futures_b.each{|f|f.value}
+    futures_b.each { |f| f.value }
     pool.join
   end
 
@@ -107,15 +127,15 @@ class TestRakeTestThreadPool < Rake::TestCase
     b = 5
     c = 3
 
-    result = a.times.collect do
+    result = a.times.map do
       pool.future do
-        b.times.collect do
+        b.times.map do
           pool.future { sleep rand * 0.001; c }
-        end.inject(0) { |m,f| m+f.value }
+        end.reduce(0) { |m, f| m + f.value }
       end
-    end.inject(0) { |m,f| m+f.value }
+    end.reduce(0) { |m, f| m + f.value }
 
-    assert_equal( (a*b*c), result )
+    assert_equal a * b * c, result
     pool.join
   end
 

data/test/test_thread_history_display.rb

@@ -5,7 +5,7 @@ require 'rake/thread_history_display'
 class TestThreadHistoryDisplay < Rake::TestCase
   def setup
     super
-    @time = 1000000
+    @time = 1_000_000
     @stats = []
     @display = Rake::ThreadHistoryDisplay.new(@stats)
   end
@@ -60,24 +60,34 @@ class TestThreadHistoryDisplay < Rake::TestCase
   end
 
   def test_thread_deleted
-    @stats << event(:thread_deleted, :deleted_thread => 123456, :thread_count => 12)
+    @stats << event(
+      :thread_deleted,
+      :deleted_thread => 123_456,
+      :thread_count => 12)
     out, _ = capture_io do
       @display.show
     end
-    assert_match(/^ *1000000 +A +thread_deleted( +deleted_thread:B| +thread_count:12){2}$/, out)
+    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)
+    @stats << event(
+      :thread_created,
+      :new_thread => 123_456,
+      :thread_count => 13)
     out, _ = capture_io do
       @display.show
     end
-    assert_match(/^ *1000000 +A +thread_created( +new_thread:B| +thread_count:13){2}$/, out)
+    assert_match(
+      /^ *1000000 +A +thread_created( +new_thread:B| +thread_count:13){2}$/,
+      out)
   end
 
   private
 
-  def event(type, data={})
+  def event(type, data = {})
     result = {
       :event => type,
       :time  => @time / 1_000_000.0,

data/test/test_trace_output.rb

@@ -6,10 +6,12 @@ class TestTraceOutput < Rake::TestCase
 
   class PrintSpy
     attr_reader :result, :calls
+
     def initialize
       @result = ""
       @calls = 0
     end
+
     def print(string)
       @result << string
       @calls += 1

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rake
 version: !ruby/object:Gem::Version
-  version: 10.0.4
+  version: 10.1.0.beta.1
 platform: ruby
 authors:
 - Jim Weirich
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-25 00:00:00.000000000 Z
+date: 2013-04-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest