tap 0.7.9 → 0.8.0

data/bin/tap

@@ -1,63 +1,99 @@
-#require 'rdoc/usage'
-#require 'getoptlong'
-
-# add options as needed
-#opts = GetoptLong.new(
-#  [ '--help', '-h', GetoptLong::NO_ARGUMENT ])
-#  opts.each do |opt, arg|
-#    case opt
-#    when '--help' then nil
-#    end
-#  end
-
-lib_dir = File.join( File.dirname(__FILE__), "../lib/")
-require lib_dir + "tap.rb"
-
-# configure the app to app.yml if it exists
-if File.exists?("app.yml")
-  config = ERB.new( File.read("app.yml") ).result
-  config = YAML.load(config)
-  Tap::App.instance.reconfigure(config) if config
+# usage: tap <command> {options} [args]
+#
+# examples:
+#   tap generate root /path/to/root      # generates a root dir
+#   tap run taskname --option input      # runs the 'taskname' task
+#
+# help:
+#   tap help                             # prints this help
+#   tap command --help                   # prints help for 'command'
+
+require File.join( File.dirname(__FILE__), "../lib/tap.rb")
+require "tap/script"
+
+app = Tap::App.instance
+script = Tap::Script.instance
+
+begin
+  # configure the app to tap.yml if it exists
+  config_file = Tap::Script.config_filepath(Dir.pwd)
+  config = Tap::Script.read_config(config_file)
+  script.configure_app(config)
+rescue(Exception)
+  # catch errors and exit gracefully
+  # (errors usu from gem loading errors)
+  puts "Configuration error: #{$!.message}"
+  puts "Check #{config_file} configurations"
+  exit(1)
+end
+
+# alert the user to the root directory if it's not Dir.pwd
+unless app.options.quiet || app.root == File.expand_path(Dir.pwd)
+  puts "root: #{app.root}" 
+end
+
+#
+# run before script
+#
+begin
+  eval(script.config.before.to_s)
+rescue
+  puts "Error in before script."
+  if app.options.debug
+    raise 
+  else
+    puts $!.message
+    exit(1)
+  end
 end
 
 begin
+  available_commands = script.config.scripts
   command = ARGV.shift
+
   case command  
-  when "help", "?", nil 
-    puts "usage: tap <command> [options] [args]"
+  when "--help", "-h", "help", "?", nil 
+    # give some help
+    puts Tap::Script.usage(__FILE__)
+    puts
     puts "available commands:"
-    
-    commands = Tap::App.instance.glob(:script).collect do |script|
-      next unless File.extname(script) == ".rb" 
-      Tap::App.instance.relative_filepath(:script, script).chomp(".rb")
-    end
-    Tap::App.glob(lib_dir + "tap/script/**/*").each do |script|
-      next unless File.extname(script) == ".rb" 
-      command = Tap::App.relative_filepath(lib_dir + "tap/script", script).chomp(".rb")
-      commands << command unless commands.include?(command)
-    end
+
+    commands = available_commands.keys
+    commands.unshift("help")
     
     print "  "
     puts commands.sort.join("\n  ")
     puts
-    
-  else
-    app_script_filepath = Tap::App.instance.filepath(:script, command + ".rb")
-    tap_script_filepath = lib_dir + "tap/script/#{command}.rb"
-
-    if File.exists?(app_script_filepath)
-      load app_script_filepath
-    elsif File.exists?(tap_script_filepath)
-      load tap_script_filepath
+    puts "version #{Tap::VERSION} -- #{Tap::HOMEPAGE}"
+  else
+    if available_commands.has_key?(command)
+      # run the script, if it exists
+      load available_commands[command]
     else
-      raise "Unknown command: '#{command}'"
+      puts "Unknown command: '#{command}'"
+      puts "Type 'tap help' for usage information."
     end
   end
 rescue
-  if Tap::App.instance.options.debug
+  if app.options.debug
+    raise 
+  else
+    puts $!.message
+    puts "Type 'tap #{command} --help' for usage information."
+  end
+end
+
+#
+# run after script
+#
+begin
+  eval(script.config.after.to_s) 
+rescue
+  puts "Error in after script."
+  if app.options.debug
     raise 
   else
     puts $!.message
-    puts "Type 'tap help' for usage information."
+    exit(1)
   end
 end

data/lib/tap.rb

@@ -1,15 +1,44 @@
-require 'active_support'
+# gem_original_require (set in rubygems) is used here to speed up 
+# requires when possible... ok since I'm manually activating the
+# neeeded gems. 
+require 'rubygems'
+
+gem_original_require 'yaml'                   # expensive to load
+gem_original_require 'logger'
+gem_original_require 'ostruct'
+gem_original_require 'thread'
+gem_original_require 'monitor'
+gem_original_require 'erb'
+
+# Loading activesupport piecemeal like this cuts the tap load time in half.
+gem 'activesupport'
+
+gem_original_require 'active_support/core_ext/array/extract_options.rb'
+class Array #:nodoc:
+  include ActiveSupport::CoreExtensions::Array::ExtractOptions
+end
+gem_original_require 'active_support/core_ext/class.rb'
+gem_original_require 'active_support/core_ext/module.rb'
+gem_original_require 'active_support/core_ext/symbol.rb'
+gem_original_require 'active_support/core_ext/string.rb'
+gem_original_require 'active_support/core_ext/blank.rb'
+gem_original_require 'active_support/core_ext/hash/keys.rb'
+gem_original_require 'active_support/dependencies'
+class Hash #:nodoc:
+  include ActiveSupport::CoreExtensions::Hash::Keys
+end
 
 $:.unshift File.dirname(__FILE__)
 
-require 'tap/version'
-require 'tap/root'
-require 'tap/app'
-require 'tap/task'
-require 'tap/workflow'
-require 'tap/file_task'
-require 'tap/support/audit'
-require 'tap/support/logger'
-require 'tap/support/templater'
-require 'tap/support/batch_queue'
-require 'tap/support/run_error'
+gem_original_require 'tap/support/audit'
+gem_original_require 'tap/support/task_configuration'
+gem_original_require 'tap/support/logger'
+gem_original_require 'tap/support/templater'
+gem_original_require 'tap/support/batch_queue'
+gem_original_require 'tap/support/run_error'
+gem_original_require 'tap/version'
+gem_original_require 'tap/root'
+gem_original_require 'tap/app'
+gem_original_require 'tap/task'
+gem_original_require 'tap/workflow'
+gem_original_require 'tap/file_task'

data/lib/tap/app.rb

@@ -1,33 +1,23 @@
-require 'yaml'
-require 'logger'
-require 'ostruct'
-require 'getoptlong'
-require 'monitor'
-require 'thread'
-require 'thwait'
-require 'erb'
-
 module Tap
   
   # == Overview
   #
   # App coordinates the setup and running of tasks, and provides an interface 
   # to the application directory structure.  App is convenient for use within 
-  # scripts, and can be extended with various modules to provide command line
-  # utilites or to be integrated within a tap server.  
+  # scripts, and provides the basis for the 'tap' command line application.  
   #
-  # All tasks have an App (by default App.instance) which helps set the task 
-  # up by loading configuration templates from the application directory, and
-  # to which all queue commands are issued.  Tasks also access application-
+  # All tasks have an App (by default App.instance) which helps initialize the 
+  # task by loading configuration templates from the application directory.  
+  # Task queue commands are passed to app, and tasks access application-
   # wide resources like the logger and various options through App.
   #
   #   task = Task.new {|task, input| input += 1 }
   #   task.app             # => App.instance
-  #   task.queue 1,2,3
+  #   task.enq 1,2,3
   #
-  #   app.run      
+  #   task.app.run      
   #
-  #   task.outputs.collect do |audit| 
+  #   task.results.collect do |audit| 
   #     audit._current
   #   end                 # => [2,3,4]
   #
@@ -38,29 +28,32 @@ module Tap
   # Multithreaded tasks execute cosynchronously, each on their own thread.
   #
   # Workflows can be achieved by setting the condition and on_complete blocks
-  # for a task.  Tasks are skipped in the queue until the condition block is
-  # met with the currently queued inputs.  When a task finishes, it will
-  # execute the on_complete block where results can be dispacted to other
-  # tasks, and these tasks queued for execution.  
+  # for a task.  Tasks are skipped until their condition block is met by the 
+  # queued inputs.  When a task finishes, it executes its on_complete block,
+  # thereby allowing results to be dispatched to other tasks.  
   #
   # In this system, the workflow logic exists among the tasks. App keeps on 
-  # running as long as it finds executable tasks in the queue.  
+  # running as long as it finds executable tasks in the queue, or until it
+  # is stopped or terminated.
   #
   # === Error Handling
   #
   # When unhandled errors arise during a run, App enters a termination (rescue) 
-  # routine.  During termination a TerminationError is raised for each executing 
-  # task so that the task immediately exits, or begins executing its internal 
-  # error handling code (perhaps performing rollbacks).
+  # routine.  During termination a TerminationError is raised in each executing 
+  # task so that the task exits, or begins executing its internal error handling 
+  # code (perhaps performing rollbacks).
   #
   # Additional errors that arise during termination are collected and packaged 
   # with the orignal error into a RunError.  By default all errors are logged
-  # and the run exits.  If options.debug == true, then the RunError will be raised
-  # for further handling.
+  # and the run exits.  If options.debug == true, then the RunError will be 
+  # raised for further handling.
   #
   # Note: the task that caused the original unhandled error is no longer executing 
   # when termination begins and thus will not recieve a TerminationError.  
   #
+  #--
+  # === Auditing
+  #++
   class App < Root
     include MonitorMixin
     
@@ -68,8 +61,7 @@ module Tap
       attr_writer :instance
       
       # Returns the current instance of App.  If no instance has been set,
-      # then a new App with the default configuration will be initialized
-      # to instance. 
+      # then a new App with the default configuration will be initialized. 
       def instance
         @instance ||= App.new
       end
@@ -79,29 +71,31 @@ module Tap
         instance.run(task, *inputs)
       end
       
-      # Parses the input argument as YAML, if arg is a string that matches
-      # the YAML document specifier (ie it begins with "---\n").  Otherwise
-      # returns the argument.
-      def parse_yaml(arg)
-        arg =~ /^---\s*\n/ ? YAML.load(arg) : arg
+      # Parses the input string as YAML, if the string matches the YAML document 
+      # specifier (ie it begins with "---\s*\n").  Otherwise returns the string.
+      #
+      #   str = {'key' => 'value'}.to_yaml    # => "--- \nkey: value\n"
+      #   Tap::App.parse_yaml(str)            # => {'key' => 'value'}
+      #   Tap::App.parse_yaml("str")          # => "str"
+      def parse_yaml(str)
+        str =~ /^---\s*\n/ ? YAML.load(str) : str
       end
       
+      # Read the contents of filepath, templates these using ERB, and loads  
+      # the result as YAML.  Returns nil if filepath does not exist.
       def read_erb_yaml(filepath)
-        return nil unless File.exists?(filepath)
+        return nil if !File.exists?(filepath) || File.directory?(filepath)
         
         input = File.read(filepath)
         input = ERB.new(input).result 
         YAML.load(input)
       end
-      
-      def make_config(task, config, version=nil)
-        
-      end
     end
     
     attr_reader :options, :logger, :queue, :state
     attr_accessor :map
     
+    # The constants defining the possible App states.
     module State
       READY = 0
       RUN = 1
@@ -111,26 +105,26 @@ module Tap
     
     DEFAULT_MAX_THREADS = 10
 
-    # Creates a new App with the given configuration.  See reconfigure for
-    # configuration options.
+    # Creates a new App with the given configuration.  
+    # See reconfigure for configuration options.
     def initialize(config={})
       super()
       
       @queue = Support::BatchQueue.new
-      @threads = []
+      @threads = [].extend(MonitorMixin)
       @thread_queue = nil
       @main_thread = nil
       @state = State::READY
-   
+
       # defaults must be provided for options and logging to ensure
       # that they will be initialized by reconfigure 
       self.reconfigure( {
-        :options => {}, :logger => {}, :map => {},
+        :options => {}, :logger => {}, :map => {}
       }.merge(config) )
     end
      
-    # Returns the current configuration for the App.  
-    def config
+    # Returns the configuration of self.  
+    def config 
       {:root => self.root,
       :directories => self.directories,
       :absolute_paths => self.absolute_paths,
@@ -138,18 +132,26 @@ module Tap
       :logger => {
         :device => self.logger.logdev.dev,
         :level => self.logger.level,
-        :datetime_format => self.logger.datetime_format},
-      :load_paths => self.load_paths}      
+        :datetime_format => self.logger.datetime_format}}      
     end
     
-    # Reconfigures App with the input configurations; other configurations are not affected.
+    # Reconfigures self with the input configurations; other configurations are not affected.
+    #
+    #   app = Tap::App.new :root => "/root", :directories => {:dir => 'path/to/dir'}
+    #   app.reconfigure(
+    #     :root => "./new/root",
+    #     :logger => {:level => Logger::DEBUG})
+    #
+    #   app.root           # => File.expand_path("./new/root")
+    #   app[:dir]          # => File.expand_path("./new/root/path/to/dir")
+    #   app.logger.level   # => Logger::DEBUG
     #
     # Available configurations:
-    # root:: resets the root directory of the app using root=
-    # directories:: resets the app directories using directories= (note ALL direcotries 
-    #               are reset. use app[dir]= to set a single directory)
-    # options:: resets the application options (note ALL options are reset.  use 
-    #           app.options.opt= to set a single option)
+    # root:: resets the root directory of self using root=
+    # directories:: resets directory aliases using directories= (note ALL  
+    #               aliases are reset. use app[da]= to set a single alias)
+    # options:: resets the application options (note ALL options are reset.   
+    #           use app.options.opt= to set a single option)
     # logger:: creates and sets a new logger from the configuration 
     #
     # Available logger configurations and defaults:
@@ -162,9 +164,9 @@ module Tap
     # - Additional configurations may be added in subclasses using handle_configuration
     def reconfigure(config={})
       config = config.symbolize_keys
-      
+  
       # ensure critical keys are evaluated in the proper order
-      keys = [:root, :directories, :absolute_paths, :options, :load_paths, :loadable]
+      keys = [:root, :directories, :absolute_paths, :options]
       config.keys.each do |key|
         keys << key unless keys.include?(key)
       end 
@@ -196,33 +198,18 @@ module Tap
           self.logger = logger
         when :map
           self.map = value
-        when :load_paths
-          self.load_paths = value
-        when :loadable
-          value.each {|dir| self.load_paths << self[dir]}
         else
-          raise "Unknown configuration: #{key}" unless handle_configuation(key, value)
+          unless handle_configuation(key, value)
+            if block_given? 
+              yield(key, value)
+            else
+              raise ArgumentError.new("Unknown configuration: #{key}")
+            end
+          end
         end
       end
-    end
-    
-    #
-    # Dependencies and reloading
-    #
-    
-    def load_paths
-      Dependencies.load_paths
-    end
-    
-    def load_paths=(paths)
-      Dependencies.load_paths = paths
-    end
-    
-    def reload
-      # TODO - logging, maybe through Dependencies as
-      # RAILS_DEFAULT_LOGGER = logger  (problem with this during server?)
-      # Dependencies.log_activity = true
-      Dependencies.clear
+      
+      self
     end
     
     #
@@ -243,81 +230,95 @@ module Tap
       logger.add(level, msg, action.to_s) unless options.quiet
     end
     
-    def monitor(action="beginning", msg="", &block)
-      if options.quiet  
-        yield 
-        nil
-      else 
-        @monitoring = true
-        result = logger.monitor(action, msg, &block)
-        @monitoring = false
-        result
-      end
-    end
-    
-    def tick_monitor(action=nil, msg="", level=Logger::INFO)
-      unless options.quiet || !@monitoring
-        action.nil? ? 
-          logger.tick :
-          logger.format_add(level, msg, action.to_s) {|format| "\n" + format}
+    # Formatted log.  Works like log, but passes the current log format to the
+    # block and uses whatever format the block returns.  The format recieves 
+    # the following arguments like so:
+    #
+    #  format % [severity, timestamp, (action || '--'), msg]
+    #
+    # By default, if you don't specify a block, flog just chomps a newline off
+    # the format, so your log will be inline.
+    def flog(action="", msg="", level=Logger::INFO) # :yields: format
+      unless options.quiet
+        logger.format_add(level, msg, action) do |format| 
+          block_given? ? yield(format) : format.chomp("\n")
+        end
       end
     end
     
-    def monitor_stats(hash)
-      unless options.quiet || !@monitoring
-        logger << "\n"
-        logger << hash.stringify_keys.to_yaml
-      end
-    end
+    # def monitor(action="beginning", msg="", &block)
+    #   if options.quiet  
+    #     yield 
+    #     nil
+    #   else 
+    #     @monitoring = true
+    #     result = logger.monitor(action, msg, &block)
+    #     @monitoring = false
+    #     result
+    #   end
+    # end
+    # 
+    # def tick_monitor(action=nil, msg="", level=Logger::INFO)
+    #   unless options.quiet || !@monitoring
+    #     action.nil? ? 
+    #       logger.tick :
+    #       logger.format_add(level, msg, action.to_s) {|format| "\n" + format}
+    #   end
+    # end
+    # 
+    # def monitor_stats(hash)
+    #   unless options.quiet || !@monitoring
+    #     logger << "\n"
+    #     logger << hash.stringify_keys.to_yaml
+    #   end
+    # end
  
     #
     # Task methods
     #
     
-    # Returns the specifed task, reconfigured with config (if provided). 
-    #
-    #   t = Task.new :key => 'value'
-    #   t = app.task(t, :key => 'another')
-    #   t.config[:key]      # => 'another'
-    #
-    # If a task name is given, then the appropriate class will be loaded and 
-    # instantiated into a task with given name.  The class is the de-versioned
-    # and camelized name, or the class as specified in map.
+    # Instantiates the specifed task with config (if provided). 
     #
-    #   app.map             # => {"mapped-task" => "Task"}
+    #   app.map = {"mapped-task" => "AnotherTask"}
     #
     #   t = app.task('mapped-task-1.0', :key => 'value')
-    #   t.class             # => Task
+    #   t.class             # => AnotherTask
     #   t.name              # => "mapped-task-1.0"
     #   t.config[:key]      # => 'value'
     #
-    def task(td, config=nil)
-      t = if td.kind_of?(Tap::Task) 
-        td 
-      else 
+    # A new task is instantiated for each call to task; tasks may share the 
+    # same name. The task class is the de-versioned and camelized task name, 
+    # or the class specified in map.  The task class will be auto-loaded using 
+    # Dependencies, if needed.
+    #
+    # A LookupError is raised if the task class cannot be found.
+    def task(task_name, config=nil)
+      begin
         # lookup the corresponding class and instantiate
-        constants = task_class_name(td).split('::')
+        constants = task_class_name(task_name).split('::')
         task_class = constants.inject(Object) do |klass, const| 
-          begin
-            klass.const_get(const)
-          rescue(NameError)
-            raise "unknown task '#{td}'"
-          end 
+          klass.const_get(const)
         end
-        task_class.new(td)
+        task_class.new(task_name, config)
+      rescue(NameError)
+        raise LookupError.new("unknown task '#{task_name}'")
       end
-      
-      # reconfigure if a config is provided
-      t.config = config unless config.nil?
-      t
     end
     
+    # Returns the class name of the specified task.  If a task descriptor
+    # is given, task_class_name returns the de-versioned, camelized 
+    # descriptor, or the class name as specified in map.
+    #
+    #   t = Task.new
+    #   app.map = {"mapped-task" => "AnotherTask"}
+    #   app.task_class_name(t)                   # => "Tap::Task"
+    #   app.task_class_name('mapped-task-1.0')   # => "AnotherTask"
     def task_class_name(td)
       case td
-      when Tap::Task then td.class.to_s
+      when Tap::Task::Base then td.class.to_s
       else
         # de-version and resolve using map
-        name, version = deversion(td)
+        name, version = deversion(td.to_s)
         map.has_key?(name) ? map[name] : name.camelize
       end
     end
@@ -352,55 +353,55 @@ module Tap
     #
     # Execution methods
     #
-
+  
     # Dequeues the task and inputs and executes the task with the current task inputs.
-    # Only the provided task will be executed (ie the task batch will not be executed)
-    # and execution is on the current thread even if the task is multithreaded.  
+    # 
+    # Execute differs from run in several significant ways:
+    # - Only the provided task will be executed (ie the task batch will not be executed)
+    # - Execution is on the current thread even if the task is multithreaded.  
+    # - No error handling is performed
     #
-    # execute can only run if the application state is READY or RUN, and does not
-    # perform any error handling
-    def execute(task)
-      synchronize do
-        #log(:execute, task.to_dir, Logger::DEBUG) if options.debug
-  
-        unless state == State::READY || state == State::RUN
-          raise "cannot execute unless application state is READY or RUN" 
-        end
-     
-        if deq = queue.deq(task)
-          task, inputs = deq
-          task.execute(*inputs)
-        end
-      end
-    end
-
-    # Enqueues the task and inputs (if provided), then iterates through the queue  
-    # executing tasks using this execution cycle:
-    #  
-    #   for each enqueued task:
-    #     next unless executable?(task)
+    # Execute can only run if the application state is READY or RUN.
+    # def execute(task)
+    #   synchronize do
+    #     #log(:execute, task.to_dir, Logger::DEBUG) if options.debug
     #   
-    #     dequeue task and inputs
-    #     if multithreading is allowed and task.multithread?
-    #       execute task on a thread
-    #     else
-    #       execute task
-    #
-    # At the end of run, the queue may still contain unexecuted tasks.  These
-    # tasks require additional inputs or conditions in order to execute. Tasks
-    # may be specified as a descriptor (ex: "some/task" => SomeTask.new) or
-    # as the task itself; run returns the specified task on completion.
+    #     unless state == State::READY || state == State::RUN
+    #       raise "cannot execute unless application state is READY or RUN" 
+    #     end
+    #  
+    #     if deq = queue.deq(task)
+    #       task, inputs = deq
+    #       task.execute(*inputs)
+    #     end
+    #   end
+    # end
+
+    # Enqueues the task and inputs (if provided), then begins the run cycle.
+    # 
+    # During the run cycle, the app will iterate through the queue and execute
+    # tasks.  Tasks will be executed ONLY if task.executable? returns true with
+    # the currently enqueued inputs.  Tasks are executed on their own thread if
+    # task.multithread? is true. 
+    #
+    # As a result of these rules, the queue may still contain unexecuted tasks
+    # a the end of run.  These tasks require additional inputs or conditions 
+    # in order to execute.  Execution errors are handled as described above.
+    #
+    # Tasks may be specified as a task descriptor (ex: "sample/task") or provided 
+    # directly.  Task descriptors are resolved using task.  
+    #
+    # run returns the specified task on completion.
     def run(td=nil, *inputs)
       synchronize do
         # TODO: log starting run
         
         # lookup and enqueue the task, if provided
-        specified_task = task(td) if td
+        specified_task = (td == nil || td.kind_of?(Tap::Task::Base) ? td : task(td))
         queue.enq(specified_task, *inputs) if specified_task
 
         # generate threading variables
         self.state = State::RUN
-        self.main_thread = Thread.current
         max_threads = options.max_threads || DEFAULT_MAX_THREADS
         self.thread_queue = max_threads > 0 ? Queue.new : nil
         
@@ -461,8 +462,8 @@ module Tap
           # executed. collect any errors that arise during
           # termination. 
           clear_thread_queue
-          errors = terminate_threads
-
+          errors = clear_threads(false)
+   
           # handle the errors accordingly
           if options.debug
             raise Tap::Support::RunError.new($!, errors)
@@ -477,7 +478,6 @@ module Tap
         
         # reset run variables
         self.thread_queue = nil
-        self.main_thread = nil
         self.state = State::READY
         
         # TODO: log run complete
@@ -495,26 +495,20 @@ module Tap
       self.state = State::STOP if state == State::RUN
     end
 
-    # Terminates a running application by raising an error on the
-    # main execution thread which enters the application into a 
-    # terminate (rescue) mode.  By default the error will be a 
-    # TerminateError, but another error can be provided as cause
-    # for the termination.  The application state is set to 
-    # State::TERMINATE.
-    #
-    # Termination in this way allows executing tasks to invoke
-    # their specific error handling code, perhaps performing 
-    # rollbacks.  (ie terminate should be used as a graceful
-    # exit)
+    # Signals a running application to terminate executing tasks 
+    # by setting state = State::TERMINATE.  When running tasks
+    # reach a termination check, the task will raise a Termination 
+    # error, thus allowing executing tasks to invoke their specific 
+    # error handling code, perhaps performing rollbacks.
+    #
+    # Termination checks can be manually specified in a task
+    # using the check_terminate method.  Termination checks 
+    # automatically occur before each task execution.
     #
     # Does nothing unless state is State::RUN or State::STOP.
-    def terminate(error=TerminateError.new)
+    def terminate#(error=TerminateError.new)
       if state == State::RUN || state == State::STOP
         self.state = State::TERMINATE
-        
-        # the terminate error must be raised on the main thread
-        # so that the App will enter the termination (rescue) block
-        main_thread.raise(error)
       end
     end
     
@@ -542,7 +536,7 @@ module Tap
     
     # Sets the condition block for the task.  If the task is batched, 
     # then the condition will be set for each task in the batch.
-    def condition(task, &block) # :yields: task, inputs
+    def condition(task, &block) # :yields: task, audited_inputs
       task.batch.each {|t| t.condition(&block)}
     end
     
@@ -565,8 +559,7 @@ module Tap
     # The condition block between these tasks will be set to the 
     # input block, if provided.  Batched tasks will have the pattern 
     # set for each task in the batch.
-    def sequence(*tasks, &block) # :yields: task, inputs
-      tasks.collect! {|td| task(td)}
+    def sequence(*tasks, &block) # :yields: task, audited_inputs
       current_task = tasks.shift
       
       tasks.each do |next_task|
@@ -582,7 +575,7 @@ module Tap
     # source completes.  The condition block for the targets will 
     # be set to the input block, if provided.  Batched tasks will have 
     # the pattern set for each task in the batch.
-    def fork(source, *targets, &block) # :yields: task, inputs
+    def fork(source, *targets, &block) # :yields: task, audited_inputs
       on_complete(source) do |results|
         targets.each do |target|
           # forking requires new audit trails because the same 
@@ -601,7 +594,7 @@ module Tap
     # completes.  The condition block for the target will be set to the 
     # input block, if provided.  Batched tasks will have the pattern set 
     # for each task in the batch.
-    def merge(target, *sources, &block) # :yields: task, inputs
+    def merge(target, *sources, &block) # :yields: task, audited_inputs
       sources.each do |source|
         # merging can use the existing audit trails... each distinct 
         # input is getting sent to one place (the target)
@@ -620,7 +613,7 @@ module Tap
     end
     
     attr_writer :state
-    attr_accessor :thread_queue, :main_thread, :threads
+    attr_accessor :thread_queue, :threads
     
     private
     
@@ -635,6 +628,11 @@ module Tap
           # terminated but still running.  Raise another
           # termination error to enter the termination 
           # (rescue) code.
+          
+          # BUG - if things just work out that way, terminate can 
+          # be set from a thread that had an error, then control 
+          # switches such that this is raised on the main thread.
+          # in this case it looks like THIS is the original error.
           raise TerminateError.new
         end
         
@@ -662,75 +660,74 @@ module Tap
         queue.priority_enq(task, *inputs) unless task.nil?
       end
     end
-  
-    def clear_threads
-      return if threads.empty?
+    
+    def clear_threads(raise_errors=true)
+      threads.synchronize do
+        errors = []
+        return errors if threads.empty?
       
-      # clears threads gracefully by enqueuing nils, to break
-      # the threads out of their loops, then waiting for the
-      # threads to work through the queue to the nils
-      threads.size.times { thread_queue.enq nil }
-      ThreadsWait.all_waits(*threads) do |thread|
-        # TODO - log thread clear
+        # clears threads gracefully by enqueuing nils, to break
+        # the threads out of their loops, then waiting for the
+        # threads to work through the queue to the nils
+        #
+        threads.size.times { thread_queue.enq nil }
+        while true
+          # TODO -- add a time out?
+          
+          threads.dup.each do |thread|
+            next if thread.alive?
+            threads.delete(thread)
+            error = thread["error"]
+            
+            next if error.nil?
+            raise error if raise_errors
+            
+            errors << error
+          end
+
+          break if threads.empty?
+          Thread.pass
+        end
+      
+        errors
       end
-      threads.clear
     end
     
     def start_thread
-      # start a new thread and add it to threads.
-      # threads simply loop and wait for a task to 
-      # be queued.  the thread will block until a 
-      # task is available (due to thread_queue.deq)
-      threads << Thread.new do 
-        # TODO - log thread start
+      threads.synchronize do
+        # start a new thread and add it to threads.
+        # threads simply loop and wait for a task to 
+        # be queued.  the thread will block until a 
+        # task is available (due to thread_queue.deq)
+        #
+        # TODO -- track thread index like?
+        #  thread["index"] = threads.length
+        threads << Thread.new do 
+          # TODO - log thread start
         
-        execution_loop do
-          task, inputs = thread_queue.deq
-          break if task.nil?
-           
-          # TODO: log execute task on thread #
           begin
-            task.execute(*inputs)
+            execution_loop do
+              task, inputs = thread_queue.deq
+              break if task.nil?
+            
+              # TODO: log execute task on thread #
+              task.execute(*inputs)
+            end
           rescue
             # unless you're already terminating,
             # an unhandled error should immediately
             # terminate all threads
-            if state == State::TERMINATE
-              raise $!
-            else
-              terminate($!)
-            end
+            terminate unless state == State::TERMINATE
+            Thread.current["error"] = $! unless $!.kind_of?(TerminateError)
           end
-        end 
-      end
-    end
-
-    def terminate_threads
-      # terminate each thread by raising an exception
-      # wait for the thread to exit and gather any
-      # errors that arise that are not from the 
-      # termination exception.
-      errors = []
-      threads.each_with_index do |thread, index|
-        next unless thread.alive?
-
-        begin
-          thread.raise TerminateError.new
-          thread.join
-        rescue TerminateError
-          # do not track these as errors 
-          # arising from termination
-        rescue
-          # track the thread of the error  
-          # with the error itself
-          errors[index] = $!
         end
       end
-      threads.clear
-    
-      errors
     end
     
+    # LookupErrors are raised for errors during dependency lookup
+    class LookupError < RuntimeError # :nodoc:
+    end
+
     # TerminateErrors are raised to kill executing tasks when terminate 
     # is called on an running App.  
     class TerminateError < RuntimeError