drake 0.8.4.1.0.18 → 0.8.4.1.1.0

data/Rakefile.drake

@@ -1,28 +1,6 @@
 
-require 'fileutils'
-
-######################################################################
-# git
-
 def git(*args)
-  cmd = ["git"] + args
-  sh(*cmd)
-end
-
-task :add_contrib_first_time => :init_contrib do
-  git(*%w!merge --squash -s ours --no-commit comp_tree/master!)
-  git(*%w!read-tree --prefix=contrib/comp_tree -u comp_tree/master!)
-  git("commit", "-m", "add comp_tree package")
-end
-
-task :init_contrib do
-  unless `git remote`.split.include? "comp_tree"
-    git(*%w!remote add -f comp_tree git@github.com:quix/comp_tree.git!)
-  end
-end
-
-task :run_pull_contrib => :init_contrib do
-  git(*%w!pull --no-commit -s subtree comp_tree master!)
+  sh("git", *args)
 end
 
 task :pull_mainline do
@@ -31,14 +9,7 @@ task :pull_mainline do
           refs/heads/master:refs/heads/origin!)
 end
 
-task :pull_contrib => [ :init_contrib, :run_pull_contrib ]
-
-######################################################################
-# drake_release
-
-task :drake_prerelease => [:clean, :gemspec] do
-  rm_rf("html")
-  rm_rf("pkg")
+task :drake_prerelease => [:clobber, :gemspec] do
   unless `git status` =~ %r!nothing to commit \(working directory clean\)!
     raise "Directory not clean"
   end

data/lib/rake.rb

@@ -29,7 +29,7 @@
 # as a library via a require statement, but it can be distributed
 # independently as an application.
 
-RAKEVERSION = '0.8.4.1.0.18'
+RAKEVERSION = '0.8.4.1.1.0'
 
 require 'rbconfig'
 require 'fileutils'
@@ -581,9 +581,8 @@ module Rake
     end
 
     def base_invoke(*args) #:nodoc:
-      invoke_with_call_chain(
-        TaskArguments.new(arg_names, args),
-        InvocationChain::EMPTY)
+      task_args = TaskArguments.new(arg_names, args)
+      invoke_with_call_chain(task_args, InvocationChain::EMPTY)
     end
 
     # Invoke the task if it is needed.  Prerequites are invoked first.
@@ -591,12 +590,12 @@ module Rake
       if application.num_threads == 1
         base_invoke(*args)
       else
-        if application.parallel_lock.locked?
+        if application.parallel.lock.locked?
           raise "Calling Task#invoke within a task is not allowed."
         end
-        application.parallel_lock.synchronize {
-          application.parallel_tasks.clear
-          application.parallel_parent_flags.clear
+        application.parallel.lock.synchronize {
+          application.parallel.tasks.clear
+          application.parallel.needed.clear
           base_invoke(*args)
           application.invoke_parallel(self.name)
         }
@@ -618,40 +617,25 @@ module Rake
           @prerequisites = @prerequisites.sort_by { rand }
         end
 
-        prereqs = 
-          if application.num_threads == 1
-            invoke_prerequisites(task_args, new_chain)
-            nil
-          else
-            invoke_prerequisites_parallel(task_args, new_chain)
-          end
-
         if application.num_threads == 1
-          #
-          # single-threaded mode
-          #
-          if needed?
-            execute(task_args) 
-          end
+          invoke_prerequisites(task_args, new_chain)
+          execute(task_args) if needed?
         else
           #
-          # parallel mode
+          # Parallel mode -- gather tasks for batch execution.
           #
           # Either the task knows it's needed or we've marked it as
-          # such.  See next comments.
+          # needed.
           #
-          if application.parallel_parent_flags[self] or needed?
-            # gather tasks for batch execution
-            application.parallel_tasks[name] = [task_args, prereqs]
-            
-            #
-            # Since this is a dry run, parents must be manually marked
-            # as needed.  Files are not created or modified, so the
-            # the 'needed?' flag does not propagate.
-            #
+          # Why do we manually mark tasks as needed?  Since this is a
+          # dry run, files are not created or modified.  Therefore the
+          # 'needed?' result does not propagate through the recursion.
+          #
+          prereqs = invoke_prerequisites_parallel(task_args, new_chain)
+          if needed? or application.parallel.needed[self]
+            application.parallel.tasks[name] = [task_args, prereqs]
             unless invocation_chain == InvocationChain::EMPTY
-              application.
-                parallel_parent_flags[invocation_chain.value] = true
+              application.parallel.needed[invocation_chain.value] = true
             end
           end
         end
@@ -1028,19 +1012,17 @@ end
 #
 # +seq+ : Force tasks to be executed sequentially.
 #
-(class << self ; self ; end).class_eval {
-  # use this form to cleanly hide the lambda
-  seq_lambda = lambda { |*task_names|
+def seq
+  Rake::SEQ_LAMBDA
+end
+module Rake
+  SEQ_LAMBDA = lambda { |*task_names|
     (1...task_names.size).each { |n|
       task task_names[n] => task_names[n - 1]
     }
     task_names.last
   }
-  
-  define_method(:seq) {
-    seq_lambda
-  }
-}
+end
 
 # ###########################################################################
 # This a FileUtils extension that defines several additional commands to be
@@ -1773,9 +1755,7 @@ module Rake
     alias :last_comment :last_description    # Backwards compatibility
 
     attr_accessor :num_threads
-    attr_reader :parallel_tasks #:nodoc:
-    attr_reader :parallel_lock #:nodoc:
-    attr_reader :parallel_parent_flags #:nodoc:
+    attr_reader :parallel
 
     def initialize
       super
@@ -1785,9 +1765,11 @@ module Rake
       @last_description = nil
 
       @num_threads = 1
-      @parallel_tasks = Hash.new
-      @parallel_lock = Mutex.new
-      @parallel_parent_flags = Hash.new
+
+      @parallel = Struct.new(:tasks, :needed, :lock).new
+      @parallel.tasks = Hash.new
+      @parallel.needed = Hash.new
+      @parallel.lock = Mutex.new
     end
 
     def create_rule(*args, &block)

data/lib/rake/comp_tree/algorithm.rb

@@ -16,9 +16,7 @@ module Rake::CompTree
 
     def compute_multithreaded(root, num_threads)
       #trace "Computing #{root.name} with #{num_threads} threads"
-
-      result = nil
-
+      finished = nil
       tree_mutex = Mutex.new
       node_finished_condition = ConditionVariable.new
       thread_wake_condition = ConditionVariable.new
@@ -37,8 +35,8 @@ module Rake::CompTree
 
           loop_with(:leave, :again) {
             node = tree_mutex.synchronize {
-              #trace "Thread #{thread_index} aquired tree lock; begin node search"
-              if result
+              #trace "Thread #{thread_index} acquired tree lock; begin search"
+              if finished
                 #trace "Thread #{thread_index} detected finish"
                 num_threads_in_use -= 1
                 throw :leave
@@ -46,7 +44,8 @@ module Rake::CompTree
                 #
                 # Find a node.  The node we obtain, if any, will be locked.
                 #
-                if node = find_node(root)
+                node = find_node(root)
+                if node
                   #trace "Thread #{thread_index} found node #{node.name}"
                   node
                 else
@@ -58,7 +57,10 @@ module Rake::CompTree
             }
 
             #trace "Thread #{thread_index} computing node"
-            node_result = compute_node(node)
+            #debug {
+            #  node.trace_compute
+            #}
+            node.compute
             #trace "Thread #{thread_index} node computed; waiting for tree lock"
 
             tree_mutex.synchronize {
@@ -66,25 +68,28 @@ module Rake::CompTree
               #debug {
               #  name = "#{node.name}" + ((node == root) ? " (ROOT NODE)" : "")
               #  initial = "Thread #{thread_index} compute result for #{name}: "
-              #  status = node_result.is_a?(Exception) ? "error" : "success"
+              #  status = node.computed.is_a?(Exception) ? "error" : "success"
               #  trace initial + status
-              #  trace "Thread #{thread_index} node result: #{node_result}"
+              #  trace "Thread #{thread_index} node result: #{node.result}"
               #}
 
-              node.result = node_result
-
+              if node.computed.is_a? Exception
+                #
+                # An error occurred; we are done.
+                #
+                finished = node.computed
+              elsif node == root
+                #
+                # Root node was computed; we are done.
+                #
+                finished = true
+              end
+                
               #
               # remove locks for this node (shared lock and own lock)
               #
               node.unlock
 
-              if node == root or node_result.is_a? Exception
-                #
-                # Root node was computed or error occurred; we are done.
-                #
-                result = node_result
-              end
-                
               #
               # Tell the main thread that another node was computed.
               #
@@ -106,7 +111,7 @@ module Rake::CompTree
           #trace "Main: waking threads"
           thread_wake_condition.broadcast
 
-          if result
+          if finished
             #trace "Main: detected finish."
             break
           end
@@ -129,17 +134,17 @@ module Rake::CompTree
       }
 
       #trace "Main: computation done."
-      if result.is_a? Exception
-        raise result
+      if finished.is_a? Exception
+        raise finished
       else
-        result
+        root.result
       end
     end
 
     def find_node(node)
       # --- only called inside shared tree mutex
       #trace "Looking for a node, starting with #{node.name}"
-      if node.result
+      if node.computed
         #
         # already computed
         #
@@ -158,20 +163,10 @@ module Rake::CompTree
         #
         #trace "Checking #{node.name}'s children"
         node.each_child { |child|
-          if next_node = find_node(child)
-            return next_node
-          end
+          next_node = find_node(child) and return next_node
         }
         nil
       end
     end
-
-    def compute_node(node)
-      begin
-        node.compute
-      rescue Exception => e
-        e
-      end
-    end
   end
 end

data/lib/rake/comp_tree/comp_tree.rb

@@ -0,0 +1,42 @@
+# 
+# Copyright (c) 2008 James M. Lawrence.  All rights reserved.
+# 
+# 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/comp_tree/driver'
+
+module Rake end
+module Rake::CompTree
+  class << self
+    #
+    # Build and run a new computation tree.
+    #
+    # A Driver instance is passed to the given block.
+    #
+    # Options hash:
+    #
+    # <tt>:node_class</tt> -- (Class) CompTree::Node subclass from
+    # which nodes are created.
+    #
+    def build(opts = nil)
+      yield Driver.new(opts)
+    end
+  end
+end

data/lib/rake/comp_tree/driver.rb

@@ -13,9 +13,9 @@ module Rake::CompTree
   #
   class Driver
     include Algorithm
-    
+
     #
-    # Begin a new computation tree.
+    # Build and run a new computation tree.
     #
     # Options hash:
     #
@@ -23,18 +23,14 @@ module Rake::CompTree
     # which nodes are created.
     #
     def initialize(opts = nil)
-      @node_class =
+      @node_class = (
         if opts and opts[:node_class]
           opts[:node_class]
         else
           Node
         end
-
+      )
       @nodes = Hash.new
-
-      if block_given?
-        yield self
-      end
     end
 
     #
@@ -45,55 +41,43 @@ module Rake::CompTree
     #
     # Define a computation node.
     #
-    # There are three distinct forms of a node definition.  In each of
-    # the following examples, a computation node named +area+ is
-    # defined which depends on the nodes +height+, +width+, +offset+.
+    # The first argument is the name of the node to define.
+    # Subsequent arguments are the names of this node's children.
     #
-    # The method_missing form:
-    #  driver.define_area(:width, :height, :offset) { |width, height, offset|
-    #    width*height - offset
-    #  }
+    # The values of the child nodes are passed to the block.  The
+    # block returns the result of this node.
     #
-    # The eval form:
-    #  driver.define_area :width, :height, :offset, %{
-    #    width*height - offset
-    #  }
-    # (Note the '%' before the brace.)
+    # In this example, a computation node named +area+ is defined
+    # which depends on the nodes +width+ and +height+.
     #
-    # The raw form:
-    #  driver.define(:area, :width, :height, :offset) { |width, height, offset|
-    #    width*height - offset
-    #  }
+    #   driver.define(:area, :width, :height) { |width, height|
+    #     width*height
+    #   }
     #
     def define(*args, &block)
       parent_name = args.first
       children_names = args[1..-1]
       
       unless parent_name
-        raise Error::ArgumentError, "No name given for node"
+        raise ArgumentError, "No name given for node"
       end
       
       #
       # retrieve or create parent and children
       #
-      parent =
-        if t = @nodes[parent_name]
-          t
-        else 
-          @nodes[parent_name] = @node_class.new(parent_name)
-        end
+      parent = @nodes[parent_name] || (
+        @nodes[parent_name] = @node_class.new(parent_name)
+      )
 
       if parent.function
-        raise Error::RedefinitionError, "Node #{parent.name} already defined."
+        raise RedefinitionError, "Node `#{parent.name.inspect}' redefined."
       end
       parent.function = block
       
       children = children_names.map { |child_name|
-        if t = @nodes[child_name]
-          t
-        else
+        @nodes[child_name] || (
           @nodes[child_name] = @node_class.new(child_name)
-        end
+        )
       }
 
       #
@@ -105,72 +89,37 @@ module Rake::CompTree
       }
     end
 
-    #
-    # parsing/evaling helper
-    #
-    def evaling_define(*args) #:nodoc:
-      function_name = args[0]
-      function_arg_names = args[1..-2]
-      function_string = args.last.to_str
-      
-      comma_separated = function_arg_names.map { |name|
-        name.to_s
-      }.join(",")
-
-      eval_me = %{ 
-        lambda { |#{comma_separated}|
-          #{function_string}
-        }
-      }
-
-      function = eval(eval_me, TOPLEVEL_BINDING)
-
-      define(function_name, *function_arg_names, &function)
-    end
-
-    def method_missing(symbol, *args, &block) #:nodoc:
-      if match = symbol.to_s.match(%r!\Adefine_(\w+)\Z!)
-        method_name = match.captures.first.to_sym
-        if block
-          define(method_name, *args, &block)
-        else
-          evaling_define(method_name, *args)
-        end
-      else
-        super(symbol, *args, &block)
-      end
-    end
-
     #
     # Mark this node and all its children as uncomputed.
     #
     # Arguments:
     #
-    # +name+ -- (Symbol) node name.
+    # +name+ -- unique node identifier (usually a symbol).
     #
     def reset(name)
       @nodes[name].reset
     end
 
     #
-    # Check for a cyclic graph below the given node.  Raises
-    # CompTree::Error::CircularError if found.
+    # Check for a cyclic graph below the given node.  If found,
+    # returns the names of the nodes (in order) which form a loop.
+    # Otherwise returns nil.
     #
     # Arguments:
     #
-    # +name+ -- (Symbol) node name.
+    # +name+ -- unique node identifier (usually a symbol).
     #
     def check_circular(name)
-      helper = lambda { |root, chain|
+      helper = Proc.new { |root, chain|
         if chain.include? root
-          raise Error::CircularError,
-            "Circular dependency detected: #{root} => #{chain.last} => #{root}"
+          return chain + [root]
         end
         @nodes[root].children.each { |child|
           helper.call(child.name, chain + [root])
         }
       }
       helper.call(name, [])
+      nil
     end
 
     #
@@ -178,18 +127,23 @@ module Rake::CompTree
     #
     # Arguments:
     #
-    # +name+ -- (Symbol) node name.
+    # +name+ -- unique node identifier (usually a symbol).
     #
     # +threads+ -- (Integer) number of threads.
     #
-    def compute(name, threads)
+    # compute(:volume, :threads => 4) syntax is also accepted.
+    #
+    def compute(name, opts)
+      threads = (opts.respond_to?(:to_i) ? opts : opts[:threads]).to_i
       root = @nodes[name]
 
       if threads < 1
-        raise Error::ArgumentError, "threads is #{threads}"
+        raise ArgumentError, "threads is #{threads}"
       end
 
-      if threads == 1
+      if root.computed
+        root.result
+      elsif threads == 1
         root.result = root.compute_now
       else
         compute_multithreaded(root, threads)

data/lib/rake/comp_tree/error.rb

@@ -1,28 +1,23 @@
 
 module Rake end
 module Rake::CompTree
-  module Error
-    # Base class for CompTree errors.
-    class Base < StandardError ; end
+  # Base class for CompTree errors.
+  class Error < StandardError ; end
     
-    # Internal error inside CompTree.  Please send a bug report.
-    class AssertionFailed < Base ; end
-    
-    # Bad arguments were passed to a method.
-    class ArgumentError < Base ; end
-    
-    #
-    # Attempt to redefine a Node.
-    #
-    # If you wish to only replace the function, set
-    #   driver.nodes[name].function = some_new_lambda
-    #
-    class RedefinitionError < Base ; end
-    
-    # A Cyclic graph was detected.
-    class CircularError < Base ; end
-
-    # No function was defined for this node.
-    class NoFunctionError < Base ; end
-  end
+  # Internal error inside CompTree.  Please send a bug report.
+  class AssertionFailedError < Error ; end
+  
+  # Bad arguments were passed to a method.
+  class ArgumentError < Error ; end
+  
+  #
+  # Attempt to redefine a Node.
+  #
+  # If you wish to only replace the function, set
+  #   driver.nodes[name].function = some_new_lambda
+  #
+  class RedefinitionError < Error ; end
+  
+  # No function was defined for this node.
+  class NoFunctionError < Error ; end
 end

data/lib/rake/comp_tree/node.rb

@@ -13,6 +13,7 @@ module Rake::CompTree
     attr_accessor :children             #:nodoc:
     attr_accessor :function             #:nodoc:
     attr_accessor :result               #:nodoc:
+    attr_accessor :computed             #:nodoc:
     attr_accessor :shared_lock          #:nodoc:
 
     #
@@ -23,6 +24,7 @@ module Rake::CompTree
       @mutex = Mutex.new
       @children = []
       @parents = []
+      @function = nil
       reset_self
     end
 
@@ -33,6 +35,7 @@ module Rake::CompTree
       @shared_lock = 0
       @children_results = nil
       @result = nil
+      @computed = nil
     end
 
     #
@@ -81,14 +84,18 @@ module Rake::CompTree
     # If all children have been computed, return their results;
     # otherwise return nil.
     #
+    # Do not assign to @children_results since own lock is not
+    # necessarily aquired.
+    #
     def find_children_results #:nodoc:
-      if @children_results
-        @children_results
-      else
+      @children_results or (
         @children.map { |child|
-          child.result or return nil
+          unless child.computed
+            return nil
+          end
+          child.result
         }
-      end
+      )
     end
 
     def children_results=(value) #:nodoc:
@@ -99,9 +106,9 @@ module Rake::CompTree
     #  debug {
     #    # --- own mutex
     #    trace "Computing #{@name}"
-    #    raise Error::AssertionFailed if @result
-    #    raise Error::AssertionFailed unless @mutex.locked?
-    #    raise Error::AssertionFailed unless @children_results
+    #    raise AssertionFailedError if @computed
+    #    raise AssertionFailedError unless @mutex.locked?
+    #    raise AssertionFailedError unless @children_results
     #  }
     #end
 
@@ -110,11 +117,17 @@ module Rake::CompTree
     # already acquired.
     #
     def compute #:nodoc:
-      unless defined?(@function) and @function
-        raise Error::NoFunctionError,
+      begin
+        unless @function
+          raise NoFunctionError,
           "No function was defined for node '#{@name.inspect}'"
+        end
+        @result = @function.call(*@children_results)
+        @computed = true
+      rescue Exception => e
+        @computed = e
       end
-      @function.call(*@children_results)
+      @result
     end
 
     def try_lock #:nodoc:
@@ -134,7 +147,7 @@ module Rake::CompTree
     def unlock #:nodoc:
       # --- shared tree mutex and own mutex
       #debug {
-      #  raise Error::AssertionFailed unless @mutex.locked?
+      #  raise AssertionFailedError unless @mutex.locked?
       #  trace "Unlocking #{@name}"
       #}
       each_upward { |node|

data/lib/rake/parallel.rb

@@ -1,28 +1,23 @@
 
-module Rake ; end
-
-require 'rake/comp_tree/driver'
+require 'rake/comp_tree/comp_tree'
 
 module Rake
   module TaskManager
     def invoke_parallel(root_task_name) # :nodoc:
-      CompTree::Driver.new { |driver|
+      CompTree.build do |driver|
         #
         # Build the computation tree from task prereqs.
         #
-        parallel_tasks.each_pair { |task_name, cache|
+        self.parallel.tasks.each_pair { |task_name, cache|
           task = self[task_name]
           task_args, prereqs = cache
-          children_names = prereqs.map { |child|
-            child.name.to_sym
-          }
-          driver.define(task_name.to_sym, *children_names) {
+          children_names = prereqs.map { |child| child.name }
+          driver.define(task_name, *children_names) {
             task.execute(task_args)
-            true
           }
         }
 
-        root_node = driver.nodes[root_task_name.to_sym]
+        root_node = driver.nodes[root_task_name]
 
         #
         # If there were nothing to do, there would be no root node.
@@ -33,16 +28,16 @@ module Rake
           #
           root_node.each_downward { |node|
             unless node.function
-              node.result = true
+              node.computed = true
             end
           }
 
           #
           # Launch the computation.
           #
-          driver.compute(root_node.name, num_threads)
+          driver.compute(root_node.name, self.num_threads)
         end
-      }
+      end
     end
   end
 end

data/test/parallel.rb

@@ -1,3 +1,4 @@
 require 'rake'
 Rake.application.num_threads = 8
+puts "- Testing multi-threaded"
 

data/test/single_threaded.rb

@@ -1,2 +1,3 @@
 require 'rake'
 Rake.application.num_threads = 1
+puts "- Testing single-threaded"

data/test/test_parallel.rb

@@ -2,9 +2,28 @@
 require 'rbconfig'
 require 'test/unit'
 
+PARALLEL_TEST_MESSAGE = <<'EOS'
+
+
+Task graph for sample parallel execution:
+
+                default
+                  / \
+                 /   \
+                a     b
+               / \
+              /   \
+             x     y
+
+EOS
+      
 if Rake.application.num_threads > 1
   class TestSimpleParallel < Test::Unit::TestCase
-    def test_1
+    def setup
+      puts PARALLEL_TEST_MESSAGE
+    end
+
+    def test_parallel
       here = File.dirname(__FILE__)
       rake = File.expand_path("#{here}/../bin/rake")
 
@@ -18,15 +37,17 @@ if Rake.application.num_threads > 1
           lib
         end
       }.call
-      
+
       [
-       "Rakefile.simple",
-       "Rakefile.seq",
-      ].each { |file|
+       ["Rakefile.simple", true],
+       ["Rakefile.seq", false],
+      ].each { |file, disp|
         (1..5).each { |n|
-          args = [rake, "--threads", n.to_s, "-f", "test/#{file}"]
-          puts("\n" + "-"*40)
-          puts(args.join(" "))
+          args = [rake, "--threads", n.to_s, "-s", "-f", "test/#{file}"]
+          if disp
+            puts "\nvisual check: #{n} thread#{n > 1 ? 's' : ''}"
+            puts args.join(" ")
+          end
           assert(ruby(*args))
         }
       }

data/test/test_top_level_functions.rb

@@ -33,14 +33,10 @@ class TestTopLevelFunctions < Test::Unit::TestCase
   end
 
   def test_import
-    if defined?(RUBY_ENGINE) and RUBY_ENGINE == "jruby"
-      puts "NOTE: skipping 'import' test for jruby"
-    else
-      Rake.application.should_receive(:add_import).with("x").once.ordered
-      Rake.application.should_receive(:add_import).with("y").once.ordered
-      Rake.application.should_receive(:add_import).with("z").once.ordered
-      import('x', 'y', 'z')
-    end
+    Rake.application.should_receive(:add_import).with("x").once.ordered
+    Rake.application.should_receive(:add_import).with("y").once.ordered
+    Rake.application.should_receive(:add_import).with("z").once.ordered
+    import('x', 'y', 'z')
   end
 
   def test_when_writing

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: drake
 version: !ruby/object:Gem::Version 
-  version: 0.8.4.1.0.18
+  version: 0.8.4.1.1.0
 platform: ruby
 authors: 
 - James M. Lawrence
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-04-02 00:00:00 -04:00
+date: 2009-04-09 00:00:00 -04:00
 default_executable: drake
 dependencies: []
 
@@ -56,6 +56,11 @@ files:
 - lib/rake/alt_system.rb
 - lib/rake/classic_namespace.rb
 - lib/rake/clean.rb
+- lib/rake/comp_tree/algorithm.rb
+- lib/rake/comp_tree/comp_tree.rb
+- lib/rake/comp_tree/driver.rb
+- lib/rake/comp_tree/error.rb
+- lib/rake/comp_tree/node.rb
 - lib/rake/contrib/compositepublisher.rb
 - lib/rake/contrib/ftptools.rb
 - lib/rake/contrib/publisher.rb
@@ -74,11 +79,6 @@ files:
 - lib/rake/testtask.rb
 - lib/rake/win32.rb
 - lib/rake.rb
-- lib/rake/comp_tree/algorithm.rb
-- lib/rake/comp_tree/diagnostic.rb
-- lib/rake/comp_tree/driver.rb
-- lib/rake/comp_tree/error.rb
-- lib/rake/comp_tree/node.rb
 - test/capture_stdout.rb
 - test/check_expansion.rb
 - test/check_no_expansion.rb

data/lib/rake/comp_tree/diagnostic.rb

@@ -1,38 +0,0 @@
-
-module Rake end
-module Rake::CompTree
-  module Diagnostic
-    module_function
-
-    def show(desc = nil, stream = STDOUT, &block)
-      if desc
-        stream.puts(desc)
-      end
-      if block
-        expression = block.call
-        result = eval(expression, block.binding)
-        stream.printf("%-16s => %s\n", expression, result.inspect)
-        result
-      end
-    end
-
-    if $DEBUG
-      def debug
-        yield
-      end
-
-      def debugging?
-        true
-      end
-
-      def trace(desc = nil, &block)
-        show(desc, STDERR, &block)
-      end
-    else
-      def debug ; end
-      def debugging? ; end
-      def trace(*args) ; end
-    end
-  end
-end
-