tap 0.8.0 → 0.9.0

data/bin/tap

@@ -1,29 +1,60 @@
+#!/usr/local/bin/ruby
 # usage: tap <command> {options} [args]
 #
 # examples:
-#   tap generate root /path/to/root      # generates a root dir
+#   tap generate 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"
 
+# setup environment
+env = Tap::Env.instance
 app = Tap::App.instance
-script = Tap::Script.instance
 
+env.logger = app.logger
+if ARGV.delete("-d-")
+  env.debug_setup
+end
+
+before = nil
+after = nil
+
+def handle_error(err)
+  case
+  when $DEBUG
+    puts err.message
+    puts
+    puts err.backtrace
+  when Tap::App.instance.debug? then raise err
+  else puts err.message
+  end
+end
+
+# configure the app to tap.yml if it exists
+default_config_file = File.expand_path( Tap::Env::DEFAULT_CONFIG_FILE )
 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)
+  env.load_config(default_config_file, app) do |app, config_file, config|
+    unless config_file == default_config_file
+      env.log(:warn, "ignoring configs: #{config_file} (#{config.keys.join(',')})", Logger::WARN) 
+      next
+    end
+    
+    before = config.delete('before')
+    after = config.delete('after')
+    
+    app.reconfigure(config)
+  end
 rescue(Exception)
   # catch errors and exit gracefully
   # (errors usu from gem loading errors)
   puts "Configuration error: #{$!.message}"
-  puts "Check #{config_file} configurations"
+  puts $!.backtrace if $DEBUG
+  puts "Check #{default_config_file} configurations"
   exit(1)
 end
 
@@ -36,25 +67,33 @@ end
 # run before script
 #
 begin
-  eval(script.config.before.to_s)
+  eval(before.to_s)
 rescue
   puts "Error in before script."
-  if app.options.debug
-    raise 
-  else
-    puts $!.message
-    exit(1)
-  end
+  handle_error($!)
+  exit(1)
 end
 
 begin
-  available_commands = script.config.scripts
+  available_commands = env.commands
   command = ARGV.shift
 
   case command  
   when "--help", "-h", "help", "?", nil 
     # give some help
-    puts Tap::Script.usage(__FILE__)
+    File.open(__FILE__) do |file|
+      bang_line = true
+      file.each_line do |line|
+        if bang_line
+          bang_line = false
+          next
+        end
+        
+        break if line !~ /^#\s?(.*)/
+        puts $1
+      end
+    end
+    
     puts
     puts "available commands:"
 
@@ -64,36 +103,28 @@ begin
     print "  "
     puts commands.sort.join("\n  ")
     puts
-    puts "version #{Tap::VERSION} -- #{Tap::HOMEPAGE}"
-  else
+    puts "version #{Tap::VERSION} -- #{Tap::WEBSITE}"
+  else
     if available_commands.has_key?(command)
-      # run the script, if it exists
+      # run the command, if it exists
       load available_commands[command]
     else
-      puts "Unknown command: '#{command}'"
-      puts "Type 'tap help' for usage information."
+      puts "Unknown command: '#{command}'"
+      puts "Type 'tap help' for usage information."
     end
   end
 rescue
-  if app.options.debug
-    raise 
-  else
-    puts $!.message
-    puts "Type 'tap #{command} --help' for usage information."
-  end
+  handle_error($!)
+  puts "Type 'tap #{command} --help' for usage information."
 end
 
 #
 # run after script
 #
 begin
-  eval(script.config.after.to_s) 
+  eval(after.to_s) 
 rescue
   puts "Error in after script."
-  if app.options.debug
-    raise 
-  else
-    puts $!.message
-    exit(1)
-  end
+  handle_error($!)
+  exit(1)
 end

data/lib/tap.rb

@@ -1,44 +1,62 @@
-# 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'
+require 'yaml'                   # expensive to load
+require 'logger'
+require 'ostruct'
+require 'thread'
+require 'erb'
+
+# Apply version-specific patches
+case RUBY_VERSION
+when /^1.9/
+  $: << File.dirname(__FILE__) + "/tap/patches/ruby19"
+  
+  # suppresses TDoc warnings
+  $DEBUG_RDOC ||= nil 
+end
 
 # 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'
+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'
+require 'active_support/core_ext/class.rb'
+require 'active_support/core_ext/module.rb'
+require 'active_support/core_ext/symbol.rb'
+require 'active_support/core_ext/string.rb'
+require 'active_support/core_ext/blank.rb'
+require 'active_support/core_ext/hash/keys.rb'
+require 'active_support/dependencies'
+require 'active_support/clean_logger'
 class Hash #:nodoc:
   include ActiveSupport::CoreExtensions::Hash::Keys
 end
 
 $:.unshift File.dirname(__FILE__)
 
-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'
+require 'tap/support/aggregator'
+require 'tap/support/audit'
+require 'tap/support/batchable'
+require 'tap/support/class_configuration'
+require 'tap/support/configurable'
+require 'tap/support/configurable_methods'
+require 'tap/support/executable'
+require 'tap/support/executable_queue'
+require 'tap/support/logger'
+require 'tap/support/run_error'
+require 'tap/support/shell_utils'
+require 'tap/support/validation'
+require 'tap/constants'
+require 'tap/env'
+require 'tap/app'
+require 'tap/task'
+require 'tap/file_task'
+require 'tap/workflow'
+require 'tap/dump'
+
+# Apply platform-specific patches
+# case RUBY_PLATFORM
+# when 'java' 
+# end

data/lib/tap/app.rb

@@ -1,63 +1,227 @@
 module Tap
   
-  # == Overview
+  # = 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 provides the basis for the 'tap' command line application.  
   #
+  # === Task Setup
+  #
   # 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 by loading configuration templates from the config directory.  Say
+  # we had the following configuration files:
+  # 
+  #   [/path/to/app/config/some/task.yml]
+  #   key: one
+  #
+  #   [/path/to/app/config/another/task.yml]
+  #   key: two
+  #
+  # Tasks initialized with the names 'some/task' and 'another/task' will 
+  # be cofigured by App like this:
+  #
+  #   app = App.instance
+  #   app.root                           # => '/path/to/app'
+  #   app[:config]                       # => '/path/to/app/config'
+  # 
+  #   some_task = Task.new 'some/task'
+  #   some_task.app                      # => App.instance
+  #   some_task.config_file              # => '/path/to/app/config/some/task.yml'
+  #   some_task.config                   # => {:key => 'one'}
   #
-  #   task = Task.new {|task, input| input += 1 }
-  #   task.app             # => App.instance
-  #   task.enq 1,2,3
+  #   another_task = Task.new 'another/task'
+  #   another_task.app                   # => App.instance
+  #   another_task.config_file           # => '/path/to/app/config/another/task.yml'
+  #   another_task.config                # => {:key => 'two'}
   #
-  #   task.app.run      
+  # If app[:config] referenced a different directory then the tasks would be 
+  # initialized from files relative to that location.  
   #
-  #   task.results.collect do |audit| 
-  #     audit._current
-  #   end                 # => [2,3,4]
+  # (see Tap::Root for more details) 
   #
   # === Running Tasks
   #
-  # Tasks are run in the order they are originally queued.  Batched tasks are
-  # all queued at the same time and therefore will execute in succession.  
-  # Multithreaded tasks execute cosynchronously, each on their own thread.
+  # Task enque commands are passed to app, and tasks access application-wide
+  # resources like the logger and options through App.  
+  #
+  #   t1 = Task.new {|task, input| input += 1 }
+  #   t1.enq 0
+  #   t1.enq 10
+  #
+  #   app.run
+  #   app.results(t1)                # => [1, 11]
+  #
+  # When a task completes, app collects its results into a data structure that 
+  # allows access to them as shown above.  This behavior can be modified by 
+  # setting an on_complete block for the task; on_complete blocks can be used 
+  # to pass results among tasks, allowing the construction of workflows.
+  #
+  #   # clear the previous results
+  #   app.aggregator.clear
+  #
+  #   t2 = Task.new {|task, input| input += 10 }
+  #   t1.on_complete {|_result| t2.enq(_result) }
+  #
+  #   t1.enq 0
+  #   t1.enq 10
+  #
+  #   app.run
+  #   app.results(t1)                # => []
+  #   app.results(t2)                # => [11, 21]
+  #
+  # Here t1 has no results because the on_complete block passed them to t2 in 
+  # a simple sequence.
+  #
+  # === Running Methods
+  #
+  # Running a task really consists of calling a method.  For tasks, the method is
+  # basically the block you provide to Task.new, although execution is mediated by 
+  # Tap::Task#execute and Tap::Task#process so that the block receives the task
+  # as a standard input.  In subclasses, the method corresponds to the subclass
+  # 'process' method.  
+  #
+  #   # the block is called to add one to the input
+  #   Task.new  {|task, input| input += 1 }
+  #
+  #   # same thing, but now in a subclass
+  #   class AddOne < Tap::Task
+  #     def process(input) input += 1 end
+  #   end
+  #
+  # When tasks are enqued, their executable method is pushed onto the queue along
+  # with the inputs for the method. Tasks can be batched such that the executable 
+  # methods of several tasks are enqued at the same time, allowing you to feed the
+  # same inputs to multiple methods at once.
+  #
+  #   t1 = Task.new  {|task, input| input += 1 }
+  #   t2 = Task.new  {|task, input| input += 10 }
+  #   Task.batch(t1, t2)             # => [t1, t2]
+  #
+  #   t1.enq 0
+  #   t2.enq 10
+  #
+  #   app.run
+  #   app.results(t1)                # => [1, 11]
+  #   app.results(t2)                # => [10, 20]
+  #
+  # App also supports multithreading; multithreaded methods execute cosynchronously, 
+  # each on their own thread (of course, you need to take care to make each method
+  # thread safe).
+  #
+  #   lock = Mutex.new
+  #   array = []
+  #   t1 = Task.new  {|task| lock.synchronize { array << Thread.current.object_id }; sleep 0.1 }
+  #   t2 = Task.new  {|task| lock.synchronize { array << Thread.current.object_id }; sleep 0.1 }
+  #   
+  #   t1.multithread = true
+  #   t1.enq
+  #   t2.multithread = true
+  #   t2.enq
+  #
+  #   app.run
+  #   array.length                   # => 2
+  #   array[0] == array[1]           # => false
+  #
+  # Since App is geared towards methods, methods from non-task objects can get 
+  # hooked into a workflow as needed.  The preferred way to do so is to make the
+  # non-task objects behave like tasks using Task::Base#initialize.  The objects
+  # can now be enqued, incorporated into workflows, and batched.
+  #
+  #   array = []
+  #   Task::Base.initialize(array, :push)
+  #
+  #   array.enq(1)
+  #   array.enq(2)
   #
-  # Workflows can be achieved by setting the condition and on_complete blocks
-  # 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.  
+  #   array.empty?                   # => true
+  #   app.run
+  #   array                          # => [1, 2]
   #
-  # In this system, the workflow logic exists among the tasks. App keeps on 
-  # running as long as it finds executable tasks in the queue, or until it
-  # is stopped or terminated.
+  # Lastly, if you can't or don't want to turn your object into a task, Tap defines 
+  # Object#_method to generate executable objects that can be enqued and 
+  # incorporated into workflows, although they cannot be batched.  The mq 
+  # (method enq) method generates and enques the method in one step.
   #
-  # === Error Handling
+  #   array = []
+  #   m = array._method(:push)
+  #    
+  #   app.enq(m, 1)
+  #   app.mq(array, :push, 2)
   #
-  # When unhandled errors arise during a run, App enters a termination (rescue) 
-  # 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).
+  #   array.empty?                   # => true
+  #   app.run
+  #   array                          # => [1, 2]
   #
-  # 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.
+  # App keeps  running as long as it finds methods in the queue, or until it is stopped 
+  # or terminated.  
   #
-  # Note: the task that caused the original unhandled error is no longer executing 
-  # when termination begins and thus will not recieve a TerminationError.  
+  # (see Tap::Support::Executable, Tap::Task, and Tap::Task::Base for more details)
   #
-  #--
   # === Auditing
-  #++
+  # 
+  # All results generated by methods are audited to track how a given input 
+  # evolves during a workflow.   
+  #
+  # To illustrate auditing, consider a workflow that uses the 'add_one' method 
+  # to add one to an input until the result is 3, then adds five more with the 
+  # 'add_five' method.  The final result should always be 8.  
+  #
+  #   t1 = Tap::Task.new('add_one') {|task, input| input += 1 }
+  #   t2 = Tap::Task.new('add_five') {|task, input| input += 5 }
+  #
+  #   t1.on_complete do |_result|
+  #     # _result is the audit; use the _current method
+  #     # to get the current value in the audit trail
+  #
+  #     _result._current < 3 ? t1.enq(_result) : t2.enq(_result)
+  #   end
+  #   
+  #   t1.enq(0)
+  #   t1.enq(1)
+  #   t1.enq(2)
+  #
+  #   app.run
+  #   app.results(t2)                # => [8,8,8]
+  #
+  # Although the results are indistinguishable, each achieved the final value
+  # through a different series of tasks. With auditing you can see how each 
+  # input came to the final value of 8:
+  #
+  #   # app.results returns the actual result values
+  #   # app._results returns the audits for these values
+  #   app._results(t2).each do |_result|
+  #     puts "How #{_result._original} became #{_result._current}:"
+  #     puts _result._to_s
+  #     puts
+  #   end
+  #
+  # Prints:
+  #
+  #   How 2 became 8:
+  #   o-[] 2
+  #   o-[add_one] 3
+  #   o-[add_five] 8
+  #
+  #   How 1 became 8:
+  #   o-[] 1
+  #   o-[add_one] 2
+  #   o-[add_one] 3
+  #   o-[add_five] 8
+  #
+  #   How 0 became 8:
+  #   o-[] 0
+  #   o-[add_one] 1
+  #   o-[add_one] 2
+  #   o-[add_one] 3
+  #   o-[add_five] 8
+  #
+  # See Tap::Support::Audit for more details.
   class App < Root
     include MonitorMixin
     
     class << self
+      # Sets the current app instance
       attr_writer :instance
       
       # Returns the current instance of App.  If no instance has been set,
@@ -65,56 +229,62 @@ module Tap
       def instance
         @instance ||= App.new
       end
-      
-      # Runs the specified task and inputs with the current instance.
-      def run(task, *inputs)
-        instance.run(task, *inputs)
-      end
-      
-      # 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 if !File.exists?(filepath) || File.directory?(filepath)
-        
-        input = File.read(filepath)
-        input = ERB.new(input).result 
-        YAML.load(input)
-      end
     end
     
-    attr_reader :options, :logger, :queue, :state
+    # An OpenStruct containing the application options.
+    attr_reader :options
+    
+    # The shared logger. 
+    attr_reader :logger
+    
+    # The application queue.
+    attr_reader :queue
+    
+    # The state of the application (see App::State).
+    attr_reader :state
+    
+    # A hash of (task_name, task_class_name) pairs mapping names to 
+    # classes for instantiating tasks that have a non-default name.   
+    # See task_class_name for more details.
     attr_accessor :map
     
-    # The constants defining the possible App states.
+    # A Tap::Support::Aggregator to collect the results of 
+    # methods that have no on_complete block.
+    attr_reader :aggregator
+    
+    # The constants defining the possible App states.  
     module State
       READY = 0
       RUN = 1
       STOP = 2
       TERMINATE = 3
+      
+      module_function
+      
+      # Returns the string corresponding to the input state value.  
+      # Returns nil for unknown states.
+      #
+      #   State.state_str(0)        # => 'READY'
+      #   State.state_str(12)       # => nil
+      def state_str(state)
+        constants.inject(nil) {|str, s| const_get(s) == state ? s.to_s : str}
+      end
     end  
     
     DEFAULT_MAX_THREADS = 10
-
+    
     # Creates a new App with the given configuration.  
     # See reconfigure for configuration options.
     def initialize(config={})
       super()
       
-      @queue = Support::BatchQueue.new
+      @state = State::READY
       @threads = [].extend(MonitorMixin)
       @thread_queue = nil
-      @main_thread = nil
-      @state = State::READY
+      @run_thread = nil
+      
+      @queue = Support::ExecutableQueue.new
+      @aggregator = Support::Aggregator.new
 
       # defaults must be provided for options and logging to ensure
       # that they will be initialized by reconfigure 
@@ -122,6 +292,21 @@ module Tap
         :options => {}, :logger => {}, :map => {}
       }.merge(config) )
     end
+    
+    # Clears the queue and aggregator.
+    #def clear(options={})
+    #  # syncrhonize?
+    #  ready
+    #  raise "cannot clear unless state == READY" unless state == State::READY
+    #
+    #  queue.clear
+    #  aggregator.clear
+    #end
+    
+    # True if options.debug or the global variable $DEBUG is true.
+    def debug?
+      options.debug || $DEBUG ? true : false
+    end
      
     # Returns the configuration of self.  
     def config 
@@ -149,7 +334,9 @@ module Tap
     # Available configurations:
     # 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)
+    #               aliases are reset. use app[dir]= to set a single alias)
+    # absolute_paths:: resets absolute path aliases using absolute_paths= (note ALL  
+    #               aliases are reset. use app[dir]= 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 
@@ -159,9 +346,7 @@ module Tap
     # level:: INFO (1) 
     # datetime_format:: %H:%M:%S
     #
-    # Notes:
-    # - Unknown configurations raise an error.  
-    # - Additional configurations may be added in subclasses using handle_configuration
+    # Unknown configurations raise an error.  
     def reconfigure(config={})
       config = config.symbolize_keys
   
@@ -212,24 +397,89 @@ module Tap
       self
     end
     
+    # Unloads constants loaded by Dependencies, so that they will be reloaded
+    # (with any changes made) next time they are called.  Returns the unloaded 
+    # constants.  
+    def reload
+      unloaded = []
+      
+      # echos the behavior of Dependencies.clear, 
+      # but collects unloaded constants
+      Dependencies.loaded.clear
+      Dependencies.autoloaded_constants.each do |const| 
+        Dependencies.remove_constant const
+        unloaded << const
+      end
+      Dependencies.autoloaded_constants.clear
+      Dependencies.explicitly_unloadable_constants.each do |const| 
+        Dependencies.remove_constant const
+        unloaded << const
+      end
+      
+      unloaded
+    end
+    
+    # Looks up the specified constant, dynamically loading via Dependencies
+    # if necessary.  Returns the const_name if const_name is a Module.
+    # Yields to the optional block if the constant cannot be found; otherwise
+    # raises a LookupError.
+    def lookup_const(const_name)
+      return const_name if const_name.kind_of?(Module)
+      
+      begin
+        const_name = const_name.camelize
+        
+        case RUBY_VERSION
+        when /^1.9/
+          
+          # a check is necessary to maintain the 1.8 behavior  
+          # of lookup_const in 1.9, where ancestor constants 
+          # may be returned by a direct evaluation
+          const_name.split("::").inject(Object) do |current, const|
+            const = const.to_sym
+            
+            current.const_get(const).tap do |c|
+              unless current.const_defined?(const, false)
+                raise NameError.new("uninitialized constant #{const_name}") 
+              end
+            end
+          end
+
+        else 
+          Object.module_eval const_name
+        end
+       
+      rescue(NameError)
+        if block_given?
+          yield 
+        else
+          raise LookupError.new("unknown constant: #{const_name}")
+        end
+      end
+    end
+    
     #
     # Logging methods
     #
     
     # Sets the current logger.  The logger is extended with Support::Logger to provide 
-    # additional logging capabilities.
+    # additional logging capabilities.  The logger level is set to Logger::DEBUG if 
+    # the global variable $DEBUG is true.
     def logger=(logger)
       @logger = logger
       @logger.extend Support::Logger unless @logger.nil?
+      @logger.level = Logger::DEBUG if $DEBUG
       @logger
     end
     
     # Logs the action and message at the input level (default INFO).  
-    # Logging is suppressed if app.options.quiet
+    # Logging is suppressed if options.quiet
     def log(action, msg="", level=Logger::INFO)
       logger.add(level, msg, action.to_s) unless options.quiet
     end
     
+    # EXPERIMENTAL
+    #
     # 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:
@@ -238,6 +488,8 @@ module Tap
     #
     # By default, if you don't specify a block, flog just chomps a newline off
     # the format, so your log will be inline.
+    #
+    # BUG: Not thread safe at the moment.
     def flog(action="", msg="", level=Logger::INFO) # :yields: format
       unless options.quiet
         logger.format_add(level, msg, action) do |format| 
@@ -245,245 +497,310 @@ module Tap
         end
       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
     #
     
-    # Instantiates the specifed task with config (if provided). 
+    # Instantiates the specifed task with config (if provided).  The task
+    # class is determined by task_class.
     #
-    #   app.map = {"mapped-task" => "AnotherTask"}
+    #   t = app.task('tap/file_task')
+    #   t.class             # => Tap::FileTask
+    #   t.name              # => 'tap/file_task'
     #
+    #   app.map = {"mapped-task" => "Tap::FileTask"}
     #   t = app.task('mapped-task-1.0', :key => 'value')
-    #   t.class             # => AnotherTask
+    #   t.class             # => Tap::FileTask
     #   t.name              # => "mapped-task-1.0"
     #   t.config[:key]      # => 'value'
     #
     # 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.
+    # same name.  
+    def task(task_name, config={}, &block)
+      task_class(task_name).new(task_name, config, &block) 
+    end
+    
+    # Looks up the specifed task class.  Names are mapped to task classes 
+    # using task_class_name.
     #
-    # 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(task_name).split('::')
-        task_class = constants.inject(Object) do |klass, const| 
-          klass.const_get(const)
-        end
-        task_class.new(task_name, config)
-      rescue(NameError)
+    #   t_class = app.task_class('tap/file_task')
+    #   t_class             # => Tap::FileTask
+    #
+    #   app.map = {"mapped-task" => "Tap::FileTask"}
+    #   t_class = app.task_class('mapped-task-1.0')
+    #   t_class             # => Tap::FileTask
+    #
+    # Notes:
+    # - The task class will be auto-loaded using Dependencies, if needed.
+    # - A LookupError is raised if the task class cannot be found.
+    def task_class(task_name)
+      lookup_const task_class_name(task_name) do
         raise LookupError.new("unknown task '#{task_name}'")
       end
     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.
+    # Returns the class name of the specified task.  If the task 
+    # descriptor is a string, the class name is the de-versioned, 
+    # descriptor, or the class name as specified in map by the 
+    # de-versioned descriptor.  
+    #
+    #   app.map = {"mapped-task" => "Tap::FileTask"}
+    #   app.task_class_name('some/task_class')   # => "some/task_class" 
+    #   app.task_class_name('mapped-task-1.0')   # => "Tap::FileTask"
+    #
+    # If td is a type of Tap::Task::Base, then task_class_name 
+    # returns td.class.to_s
+    #
+    #   t1 = Task.new
+    #   app.task_class_name(t1)                   # => "Tap::Task"
+    #
+    #   t2 = Object.new.extend Tap::Task::Base
+    #   app.task_class_name(t2)                   # => "Object"
     #
-    #   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::Base then td.class.to_s
       else
         # de-version and resolve using map
         name, version = deversion(td.to_s)
-        map.has_key?(name) ? map[name] : name.camelize
+        map.has_key?(name) ? map[name].to_s : name
       end
     end
     
-    # Creates and returns an array of configuration templates for the specified file.
-    # To make templates, the contents of the file are processed using ERB, then
-    # loaded as YAML and assembled into an array of hashes. 
+    # Iteratively passes the block the configuration templates for the specified file.
+    # Ultimately these templates specify configurations for tasks, as well batched tasks,
+    # linked to to self.  If no block is specified, each_config_template collects the
+    # templates and returns them as an array.
     #
-    #   # simple.yml => "key: value"
-    #   app.config_templates("simple.yml")  # => [{"key" => "value"}]
+    # To make templates, the contents of the file are processed using ERB, then loaded 
+    # as YAML. ERB for the config files is evaluated in a binding that contains  
+    # references to self (app) and the input filepath.
     #
-    #   # array_with_erb.yml => %Q{ 
-    #   #   - key: <%= 1 %>
-    #   #   - key: <%= 1 + 1 %>}
-    #   app.config_templates("array_with_erb.yml")  # => [{"key" => 1}, {"key" => 2}]
+    #   # [simple.yml] 
+    #   #  key: value
     #
-    # If no config templates are loaded (as when the filepath does not exist, or the
-    # file is empty), then the return will be a single empty template -- [{}].
-    def config_templates(filepath)
-      config_templates = App.read_erb_yaml(filepath)
-      
-      config_templates = case config_templates
-      when Array then config_templates
-      when Hash then [config_templates]
+    #   app.each_config_template("simple.yml")  # => [{"key" => "value"}]
+    #
+    #   # [erb.yml] 
+    #   #  app: <%= app.object_id %>
+    #   #  filepath: <%= filepath %>
+    #
+    #   app.each_config_template("erb.yml")  # => [{"app" => app.object_id, "filepath" => "erb.yml"}]
+    #
+    # Batched tasks can be specified by providing an array of hashes.  
+    #
+    #   # [batched_with_erb.yml] 
+    #   #  - key: <%= 1 %>
+    #   #  - key: <%= 1 + 1 %>
+    #
+    #   app.each_config_template("batched_with_erb.yml")  # => [{"key" => 1}, {"key" => 2}]
+    #
+    # If no config templates can be loaded (as when the filepath does not exist, or  
+    # the file is empty), each_config_template passes the block a single empty template.  
+    def each_config_template(filepath) # :yields: template
+      unless block_given?
+        templates = []
+        each_config_template(filepath) {|template| templates << template}
+        return templates
+      end
+    
+      if filepath == nil
+        yield({}) 
       else
-        return [{}]
+        templates = if !File.exists?(filepath) || File.directory?(filepath)
+          nil
+        else
+          # create the reference to app for templating
+          app = self
+          input = ERB.new(File.read(filepath)).result(binding)
+          YAML.load(input)
+        end
+        
+        case templates
+        when Array 
+          templates.each do |template|
+            yield(template)
+          end
+        when Hash
+          yield(templates) 
+        else
+          yield({})
+        end 
       end
-      
-      config_templates      
+    end
+    
+    # Returns the configuration filepath for the specified task name,
+    # File.join(app['config'], task_name + ".yml"). Returns nil if 
+    # task_name==nil.
+    def config_filepath(task_name)
+      task_name == nil ? nil : filepath('config', task_name + ".yml")
     end
     
     #
     # Execution methods
     #
-  
-    # Dequeues the task and inputs and executes the task with the current task inputs.
-    # 
-    # 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.
-    # 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
+    
+    # Executes the input Executable with the inputs.  Stores the result in 
+    # aggregator unless an on_complete block is set.  Returns the audited 
+    # result.
+    def execute(m, inputs)
+      _result = m._execute(*inputs)
+      aggregator.store(_result) unless m.on_complete_block
+      _result
+    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)
+    # Sets state = State::READY unless the app has a run_thread 
+    # (ie the app is running).  Returns self.
+    def ready
+      synchronize do 
+        self.state = State::READY if self.run_thread == nil
+        self
+      end
+    end
+
+    # Runs the methods in the queue in which they were enqued. Run exists when there
+    # are no more enqued methods.  Run returns self.  An app can only run on one thread 
+    # at a time.  If run is called when self is already running, run returns immediately.
+    #
+    # === The Run Cycle
+    # During run, each method is executed sequentially on the current thread unless 
+    # m.multithread == true.  In this case run switches into a multithreaded mode and 
+    # launches up to n execution threads (where n is options.max_threads or 
+    # DEFAULT_MAX_THREADS) each of which can run a multithreaded method.  
+    #
+    # These threads will run methods until a non-multithreaded method reaches the top 
+    # of the queue.  At that point, run waits for the multithreaded methods to complete, 
+    # and then switches back into the sequential mode.  Run never executes multithreaded 
+    # and non-multithreaded methods at the same time.
+    #
+    # Run checks the state of self before executing a method.  If the state is changed
+    # to State::STOP, then no more methods will be executed (but currently running methods
+    # will continute to completion).  If the state is changed to State::TERMINATE then
+    # no more methods will be executed and currently running methods will be discontinued
+    # as described below.
+    #
+    # When a series of multithreaded methods are stopped or terminated mid-execution,
+    # several methods may be waiting for a free execution thread.  These are requeued.
+    #
+    # === Error Handling and Termination
+    # When unhandled errors arise during run, run enters a termination (rescue) 
+    # routine.  During termination a TerminationError is raised in each executing 
+    # method so that the method exits or begins executing its internal error handling 
+    # code (perhaps performing rollbacks).
+    #
+    # The TerminationError is ONLY raised when the method calls Task::Base#check_terminate
+    # This method is available to all Task::Base objects, but obviously is NOT available
+    # to Executable methods generated by _method.  These methods need to check the state
+    # of app themselves; otherwise they will continue on to completion even when app
+    # is in State::TERMINATE.
+    #
+    #   # this task will loop until app.terminate
+    #   Task.new {|task|  while(true) task.check_terminate end }
+    #
+    #   # this task will NEVER terminate
+    #   Task.new {|task|  while(true) end; task.check_terminate }
+    #
+    # Additional errors that arise during termination are collected and packaged 
+    # with the orignal error into a RunError.  By default all errors are logged
+    # and run exits.  If debug? == true, then the RunError will be raised for further 
+    # handling.
+    #
+    # Note: the method that caused the original unhandled error is no longer executing 
+    # when termination begins and thus will not recieve a TerminationError.  
+    def run
       synchronize do
-        # TODO: log starting run
-        
-        # lookup and enqueue the task, if provided
-        specified_task = (td == nil || td.kind_of?(Tap::Task::Base) ? td : task(td))
-        queue.enq(specified_task, *inputs) if specified_task
+        return self unless self.ready.state == State::READY
 
-        # generate threading variables
+        self.run_thread = Thread.current
         self.state = State::RUN
-        max_threads = options.max_threads || DEFAULT_MAX_THREADS
-        self.thread_queue = max_threads > 0 ? Queue.new : nil
-        
-        begin 
-          execution_loop do 
-            task, inputs = queue.deq
-            
-            # if no tasks were in the queue 
-            # then clear the threads and 
-            # check for tasks again
-            unless task 
-              clear_threads
-              task, inputs = queue.deq
-            end
-            
-            # break -- no executable task was found
-            break if task.nil?
-
-            if thread_queue && task.multithread?
-              # TODO: log enqueuing task to thread
-              
-              # generate threads as needed and allowed
-              # to execute the threads in the thread queue
-              start_thread if threads.size < max_threads 
-
-              # NOTE: the producer-consumer relationship of execution
-              # threads and the thread_queue means that tasks will sit
-              # waiting until an execution thread opens up.  in the most
-              # extreme case all executing tasks and all tasks in the 
-              # task_queue could be the same task, each with different
-              # inputs.  this deviates from the idea of batch processing,
-              # but should be rare and not at all fatal given execute
-              # synchronization.  
-              thread_queue.enq [task, inputs]
-            
-            else
-              # TODO: log execute task
-              
-              # wait for threads to complete
-              # before executing the main thread
-              clear_threads
-              task.execute(*inputs)
-            end
-          end
+      end
+      
+      # generate threading variables
+      max_threads = options.max_threads || DEFAULT_MAX_THREADS
+      self.thread_queue = max_threads > 0 ? Queue.new : nil
+      
+      # TODO: log starting run
+      begin 
+        execution_loop do
+          break if block_given? && yield(self) 
           
-          # if the run loop exited due to a STOP state,
-          # tasks may still be in the thread queue and/or
-          # running.  be sure these are cleared
-          if state == State::STOP
-            clear_thread_queue 
+          # if no tasks were in the queue 
+          # then clear the threads and 
+          # check for tasks again
+          if queue.empty?
             clear_threads 
+            # break -- no executable task was found
+            break if queue.empty?
           end
           
-        rescue
-          # when an error is generated, be sure to terminate
-          # all threads so they can clean up after themselves.
-          # clear the thread queue first so no more tasks are
-          # executed. collect any errors that arise during
-          # termination. 
-          clear_thread_queue
-          errors = clear_threads(false)
-   
-          # handle the errors accordingly
-          if options.debug
-            raise Tap::Support::RunError.new($!, errors)
+          m, inputs = queue.deq
+          
+          if thread_queue && m.multithread
+            # TODO: log enqueuing task to thread
+            
+            # generate threads as needed and allowed
+            # to execute the threads in the thread queue
+            start_thread if threads.size < max_threads 
+
+            # NOTE: the producer-consumer relationship of execution
+            # threads and the thread_queue means that tasks will sit
+            # waiting until an execution thread opens up.  in the most
+            # extreme case all executing tasks and all tasks in the 
+            # task_queue could be the same task, each with different
+            # inputs.  this deviates from the idea of batch processing,
+            # but should be rare and not at all fatal given execute
+            # synchronization.  
+            thread_queue.enq [m, inputs]
+          
           else
-            log($!.class, $!.message)
-            errors.each_with_index do |err, index|
-              next if err.nil?
-              log("[#{index}] #{err.class}", err.message)
-            end
+            # TODO: log execute task
+            
+            # wait for threads to complete
+            # before executing the main thread
+            clear_threads
+            execute(m, inputs)
           end
         end
         
+        # if the run loop exited due to a STOP state,
+        # tasks may still be in the thread queue and/or
+        # running.  be sure these are cleared
+        clear_thread_queue 
+        clear_threads 
+
+      rescue
+        # when an error is generated, be sure to terminate
+        # all threads so they can clean up after themselves.
+        # clear the thread queue first so no more tasks are
+        # executed. collect any errors that arise during
+        # termination. 
+        clear_thread_queue
+        errors =  [$!] + clear_threads(false)
+        errors.delete_if {|error|  error.kind_of?(TerminateError) }
+        
+        # handle the errors accordingly
+        case
+        when debug?
+          raise Tap::Support::RunError.new(errors)
+        else
+          errors.each_with_index do |err, index|
+            log("RunError [#{index}] #{err.class}", err.message)
+          end
+        end
+      ensure
+      
         # reset run variables
         self.thread_queue = nil
-        self.state = State::READY
-        
-        # TODO: log run complete
         
-        specified_task
+        synchronize do
+          self.run_thread = nil
+          self.state = State::READY
+        end
       end
+      
+      # TODO: log run complete
+      self
     end
     
     # Signals a running application to stop executing tasks in the 
@@ -492,115 +809,153 @@ module Tap
     #
     # Does nothing unless state is State::RUN.
     def stop
-      self.state = State::STOP if state == State::RUN
+      synchronize do
+        self.state = State::STOP if self.state == State::RUN
+        self
+      end
     end
 
     # 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 
+    # reach a termination check, the task raises a TerminationError,
+    # 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.
+    # using the check_terminate method (see Tap::Task::Base#check_terminate).
+    # Termination checks automatically occur before each task execution.
     #
-    # Does nothing unless state is State::RUN or State::STOP.
-    def terminate#(error=TerminateError.new)
-      if state == State::RUN || state == State::STOP
-        self.state = State::TERMINATE
+    # Does nothing if state == State::READY.
+    def terminate
+      synchronize do
+        self.state = State::TERMINATE unless self.state == State::READY
+        self
       end
     end
     
     # Returns an information string for the App.  
     #
-    #   App.new().info   # => 'state: 0 (READY) queue: 0 waiting: 0 (0) threads: 0'
+    #   App.instance.info   # => 'state: 0 (READY) queue: 0 thread_queue: 0 threads: 0 results: 0'
     #
     # Provided information:
     #
-    # state:: the integer and string values of the application state
-    # queue:: the number of tasks currently in the queue
-    # waiting:: the number of executable tasks in the queue, in parenthesis is the
-    #           number of objects in the thread queue (tasks, and perhaps nils to 
-    #           signal threads to clear)
+    # state:: the integer and string values of self.state
+    # queue:: the number of methods currently in the queue
+    # thread_queue:: number of objects in the thread queue, waiting
+    #                to be run on an execution thread (methods, and 
+    #                perhaps nils to signal threads to clear)
     # threads:: the number of execution threads
-    #
+    # results:: the total number of results in aggregator
     def info
-      state_str = State.constants.inject(nil) {|str, s| State.const_get(s) == state ? s : str}
-      "state: #{state} (#{state_str}) queue: #{queue.size} waiting: #{queue.num_executable} (#{thread_queue ? thread_queue.size : 0}) threads: #{threads.size}"
+      synchronize do
+        "state: #{state} (#{State.state_str(state)}) queue: #{queue.size} thread_queue: #{thread_queue ? thread_queue.size : 0} threads: #{threads.size} results: #{aggregator.size}"
+      end
     end
     
     #
     # workflow related
     #
     
-    # 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, audited_inputs
-      task.batch.each {|t| t.condition(&block)}
-    end
-    
-    # Sets the on_complete block for the task.  If the task is batched, 
-    # then on_complete will be set for each task in the batch.
-    def on_complete(task, &block) # :yields: results
-      task.batch.each {|t| t.on_complete(&block)}
-    end
-    
-    # Sets multithread=true for each input task.  Batched tasks will
-    # have each task in the batch multithreaded.
-    def multithread(*tasks)
-      tasks.each do |task| 
-        task.batch.each {|t| t.multithread = true}
+    # Enques the task with the inputs.  If the task is batched, then each 
+    # task in task.batch will be enqued with the inputs.  Returns task.
+    #
+    # An Executable may provided instead of a task.
+    def enq(task, *inputs)
+      case task
+      when Tap::Task::Base
+        raise "not assigned to enqueing app: #{task}" unless task.app == self
+        task.enq(*inputs)
+      when Support::Executable
+        queue.enq(task, inputs)
+      else
+        raise "Not a Task or Executable: #{task}"
       end
+      task
+    end
+
+    # Method enque.  Enques the specified method from object with the inputs.
+    # Returns the enqued method.
+    def mq(object, method_name, *inputs)
+      m = object._method(method_name)
+      enq(m, *inputs)
     end
     
     # Sets a sequence workflow pattern for the tasks such that the
     # completion of a task enqueues the next task with it's results.
-    # 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, audited_inputs
+    # Batched tasks will have the pattern set for each task in the 
+    # batch.  The current audited results are yielded to the block, 
+    # if given, before the next task is enqued.
+    #
+    # Executables may provided as well as tasks.
+    def sequence(*tasks) # :yields: _result
       current_task = tasks.shift
-      
       tasks.each do |next_task|
         # simply pass results from one task to the next.  
-        on_complete(current_task) {|results| queue.enq(next_task, *results) }
-        condition(next_task, &block)
+        current_task.on_complete do |_result| 
+          yield(_result) if block_given?
+          enq(next_task, _result)
+        end
         current_task = next_task
       end
     end
     
     # Sets a fork workflow pattern for the tasks such that each of the
     # targets will be enqueued with the results of the source when the
-    # 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, audited_inputs
-      on_complete(source) do |results|
-        targets.each do |target|
-          # forking requires new audit trails because the same 
-          # inputs are getting sent to multiple tasks
-          forked_results = results.collect {|result| result._fork }
-          queue.enq(target, *forked_results)
+    # source completes. Batched tasks will have the pattern set for each 
+    # task in the batch.  The source audited results are yielded to the 
+    # block, if given, before the targets are enqued.
+    #
+    # Executables may provided as well as tasks.
+    def fork(source, *targets) # :yields: _result
+      source.on_complete do |_result|
+        targets.each do |target| 
+          yield(_result) if block_given?
+          enq(target, _result)
         end
       end
-      targets.each do |target|
-        condition(target, &block)
-      end if block_given?
     end
     
     # Sets a merge workflow pattern for the tasks such that the results
     # of each source will be enqueued to the target when the source 
-    # 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, audited_inputs
+    # completes. Batched tasks will have the pattern set for each 
+    # task in the batch.  The source audited results are yielded to  
+    # the block, if given, before the target is enqued.
+    #
+    # Executables may provided as well as tasks.
+    def merge(target, *sources) # :yields: _result
       sources.each do |source|
         # merging can use the existing audit trails... each distinct 
         # input is getting sent to one place (the target)
-        on_complete(source) {|results| queue.enq(target, *results) }
+        source.on_complete do |_result| 
+          yield(_result) if block_given?
+          enq(target, _result)
+        end
       end
-      condition(target, &block) if block_given?
+    end
+    
+    # Returns all aggregated, audited results for the specified tasks.  
+    # Results are joined into a single array.  Arrays of tasks are 
+    # allowed as inputs. See results.
+    def _results(*tasks)
+      aggregator.retrieve_all(*tasks.flatten)
+    end
+    
+    # Returns all aggregated results for the specified tasks.  Results are
+    # joined into a single array.  Arrays of tasks are allowed as inputs.    
+    #
+    #   t1 = Task.new  {|task, input| input += 1 }
+    #   t2 = Task.new  {|task, input| input += 10 }
+    #   t3 = t2.initialize_batch_obj
+    #
+    #   t1.enq(0)
+    #   t2.enq(1)
+    #
+    #   app.run
+    #   app.results(t1, t2.batch)     # => [1, 11, 11]
+    #   app.results(t2, t1)           # => [11, 1]
+    #
+    def results(*tasks)
+      _results(tasks).collect {|_result| _result._current}
     end
     
     protected
@@ -612,30 +967,34 @@ module Tap
       false
     end
     
+    # Sets the state of the application
     attr_writer :state
-    attr_accessor :thread_queue, :threads
     
-    private
+    # The thread on which run is executing tasks.
+    attr_accessor :run_thread
     
+    # An array containing the execution threads in use by run.  
+    attr_accessor :threads
+    
+    # A Queue containing multithread tasks waiting to be run 
+    # on the execution threads.  Nil if options.max_threads= 0
+    attr_accessor :thread_queue
+    
+    private
+
     def execution_loop
       while true
         case state
         when State::STOP
           break
         when State::TERMINATE
-          # if an execution thread (main or multi) handles the
-          # termination error, then the thread may end up here --
-          # 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.
+          # if an execution thread handles the termination error, 
+          # then the thread may end up here -- terminated but still 
+          # running.  Raise another termination error to enter the 
+          # termination (rescue) code.
           raise TerminateError.new
         end
-        
+   
         yield
       end
     end
@@ -657,7 +1016,7 @@ module Tap
       # task being promoted along with it's inputs
       dequeued.reverse_each do |task, inputs|
         # TODO: log about not executing
-        queue.priority_enq(task, *inputs) unless task.nil?
+        queue.unshift(task, inputs) unless task.nil?
       end
     end
     
@@ -707,30 +1066,29 @@ module Tap
         
           begin
             execution_loop do
-              task, inputs = thread_queue.deq
-              break if task.nil?
+              m, inputs = thread_queue.deq
+              break if m.nil?
             
               # TODO: log execute task on thread #
-              task.execute(*inputs)
+              execute(m, inputs)
             end
           rescue
-            # unless you're already terminating,
             # an unhandled error should immediately
             # terminate all threads
-            terminate unless state == State::TERMINATE
-            Thread.current["error"] = $! unless $!.kind_of?(TerminateError)
+            terminate
+            Thread.current["error"] = $!
           end
         end
       end
     end
-    
+
     # LookupErrors are raised for errors during dependency lookup
-    class LookupError < RuntimeError # :nodoc:
+    class LookupError < RuntimeError 
     end
 
     # TerminateErrors are raised to kill executing tasks when terminate 
-    # is called on an running App.  
-    class TerminateError < RuntimeError
+    # is called on an running App.  They are handled by the run rescue code.
+    class TerminateError < RuntimeError 
     end
   end
 end