tap 0.8.0 → 0.9.0

data/lib/tap/support/tdoc/config_attr.rb

@@ -12,7 +12,7 @@
 # unaffected as the constants are reset after RDoc loads.
 #
 if Object.const_defined?(:RubyToken) || Object.const_defined?(:RubyLex)
-  class Object # :nodoc:
+  class Object 
     old_ruby_token = const_defined?(:RubyToken) ? remove_const(:RubyToken) : nil
     old_ruby_lex = const_defined?(:RubyLex) ? remove_const(:RubyLex) : nil
   
@@ -34,13 +34,13 @@ else
   require 'rdoc/rdoc'
 
   if Object.const_defined?(:RubyToken) && !RDoc.const_defined?(:RubyToken)
-    class Object # :nodoc:
+    class Object
       RDoc.const_set(:RubyToken, remove_const(:RubyToken))
     end
   end 
   
   if Object.const_defined?(:RubyLex) && !RDoc.const_defined?(:RubyLex)
-    class Object # :nodoc:
+    class Object
       RDoc.const_set(:RubyLex, remove_const(:RubyLex))
       RDoc::RubyLex.const_set(:RubyLex, RDoc::RubyLex)
     end
@@ -113,8 +113,8 @@ module Tap
               lines = []
             else
               if normalize_comments
-                line =~ /^\s*#(.*)/
-                line = $1.to_s.strip
+                line =~ /^\s*#\s?(.*)/
+                line = $1.to_s
               end
 
               lines << line
@@ -129,7 +129,8 @@ module Tap
         def find_class_or_module_named(name)
           return self if full_name == name
           (@classes.values + @modules.values).each do |c| 
-            return c if c.find_class_or_module_named(name)
+            res = c.find_class_or_module_named(name)
+            return res if res
           end
           nil
         end
@@ -206,7 +207,25 @@ module Tap
         # (see 'rdoc/parsers/parse_rb' line 2509)
         def parse_config(context, single, tk, comment)
           tks = get_tk_to_nl
+          
+          key_tk = nil
+          value_tk = nil
+          
+          tks.each do |token|
+            next if token.kind_of?(TkSPACE)
             
+            if key_tk == nil
+              key_tk = token if token.kind_of?(TkSYMBOL)
+            else
+              case token
+              when TkCOMMA then value_tk = token
+              else
+                value_tk = token if value_tk.kind_of?(TkCOMMA)
+                break
+              end
+            end
+          end
+
           text = ""
           if tks.last.kind_of?(TkCOMMENT)
             text = tks.last.text.chomp("\n").chomp("\r")
@@ -216,18 +235,23 @@ module Tap
               
             tmp = RDoc::CodeObject.new
             read_documentation_modifiers(tmp, RDoc::ATTR_MODIFIERS)
-            return unless tmp.document_self
+            text = nil unless tmp.document_self
           end
-              
-          key_tk = tks.select {|tk| tk.kind_of?(TkSYMBOL)}.first
-          return if key_tk.nil?
+          
+          tks.reverse_each {|token| unget_tk(token) }
+          return if key_tk == nil || text == nil
           
           arg = key_tk.text[1..-1]
+          if value_tk
+            if text =~ /(.*):no_default:(.*)/
+              text = $1 + $2
+            else
+              text += " (#{value_tk.text})" 
+            end
+          end
           att = TDoc::ConfigAttr.new(text, arg, config_rw, comment)
           att.config_declaration = get_tkread
-          
-          # TODO -- it would be nice to read the default value here...
-          
+           
           context.add_attribute(att)
         end
         
@@ -241,14 +265,14 @@ module Tap
           self.config_mode = tk.name 
           
           tks = get_tk_to_nl
-          is_config_mode_flag = tks.select do |tk| 
-            !tk.kind_of?(TkSPACE) && !tk.kind_of?(TkCOMMENT) 
+          is_config_mode_flag = tks.select do |token| 
+            !token.kind_of?(TkSPACE) && !token.kind_of?(TkCOMMENT) 
           end.empty?
 
           # If no args are given, take this as a flag for c
           return if is_config_mode_flag
             
-          tks.reverse_each {|tk| unget_tk(tk) }
+          tks.reverse_each {|token| unget_tk(token) }
           args = parse_symbol_arg
           read = get_tkread
           rw = "?"

data/lib/tap/support/validation.rb

@@ -0,0 +1,77 @@
+autoload(:PP, 'pp')
+
+module Tap
+  module Support
+    
+    # Validation generates blocks for common validations/processing of 
+    # configurations set through Configurable.  These blocks can be passed
+    # to the config declarations using an ampersand (&).
+    #
+    # See the 'Configuration' section in the Tap::Task documentation for
+    # more details on how Validation works in practice.
+    module Validation
+      
+      # Raised when Validation blocks fail.
+      class ValidationError < ArgumentError
+        def initialize(input, validations)
+          validation_str = PP.singleline_pp(validations, "")
+          super PP.singleline_pp(input, "expected #{validation_str} but was: ")
+        end
+      end
+      
+      module_function
+      
+      # Yaml conversion and checker.  Valid if any of the validations
+      # match in a case statement.  Otherwise raises an error.
+      
+      # Returns input if any of the validations match the input, as
+      # in a case statement.  Raises a ValidationError otherwise.
+      #
+      # For example:
+      #
+      #   validate(10, [Integer, nil])
+      #
+      # Does the same as:
+      #
+      #   case 10
+      #   when Integer, nil then input
+      #   else raise ValidationError.new(...)
+      #   end
+      #
+      def validate(input, validations)
+        case input
+        when *validations then input
+        else
+          raise ValidationError.new(input, validations)
+        end
+      end
+      
+      # Returns a block that calls validate using the block input
+      # and the input validations.
+      def check(*validations)
+        lambda {|input| validate(input, validations) }
+      end
+    
+      # Returns a block that loads input strings as YAML, then
+      # calls validate with the result and the input validations.
+      # If the block input is not a string, the block input is 
+      # validated.
+      #
+      #   b = yaml(Integer, nil)
+      #   b.class                 # => Proc
+      #   b.call(1)               # => 1
+      #   b.call("1")             # => 1
+      #   b.call(nil)             # => nil
+      #   b.call("str")           # => ValidationError
+      #
+      # Note: yaml is especially useful for validating configs
+      # that may be specified as strings or as an actual object.
+      def yaml(*validations)
+        lambda do |input|
+          res = input.kind_of?(String) ? YAML.load(input) : input
+          validate(res, validations)
+        end
+      end
+    end
+  end
+end

data/lib/tap/support/versions.rb

@@ -11,7 +11,7 @@ module Tap
       # 'path-version.extension'.  If no version is specified, then the filepath 
       # is returned.
       #
-      #   version("path/to/file.txt", 1.0)  # => "path/to/file-1.0.txt"
+      #   version("path/to/file.txt", 1.0)            # => "path/to/file-1.0.txt"
       #
       def version(path, version)
         version = version.to_s.strip
@@ -26,7 +26,7 @@ module Tap
       # Increments the version of the filepath by the specified increment.  
       #
       #   increment("path/to/file-1.0.txt", "0.0.1")  # => "path/to/file-1.0.1.txt"
-      #   increment("path/to/file.txt", 1.0)  # => "path/to/file-1.0.txt"
+      #   increment("path/to/file.txt", 1.0)          # => "path/to/file-1.0.txt"
       #
       def increment(path, increment)
         path, version = deversion(path)
@@ -52,43 +52,43 @@ module Tap
       # Splits the version from the input path, then returns the path and version.  
       # If no version is specified, then the returned version will be nil.
       #
-      #   deversion("path/to/file-1.0.txt")  # => ["path/to/file.txt", "1.0"]
-      #   deversion("path/to/file.txt")  # => ["path/to/file.txt", nil]
+      #   deversion("path/to/file-1.0.txt")           # => ["path/to/file.txt", "1.0"]
+      #   deversion("path/to/file.txt")               # => ["path/to/file.txt", nil]
       #
       def deversion(path)
         path =~ /^(.*)-(\d(\.?\d)*)(.*)?/ ? [$1 + $4, $2] : [path, nil]
-      end
-      
-      # A <=>  comparison for versions.  compare_versions can take strings, 
-      # integers, or even arrays representing the parts of a version.
-      #
-      #   compare_versions("1.0.0", "0.9.9")                  # => 1
-      #   compare_versions(1.1, 1.1)                               # => 0
-      #   compare_versions([0,9], [0,9,1])                    # => -1
-      def compare_versions(a,b)
-        a, b = [a,b].collect {|item| to_integer_array(item) }
-        
-        # equalize the lengths of the integer arrays
-        d = b.length - a.length
-        case 
-        when d < 0 then b.concat Array.new(-d, 0)
-        when d > 0 then a.concat Array.new(d, 0)
-        end 
-      
-        a <=> b
-      end
-      
-      private
-      
-      # Converts an input argument (typically a string  or an array) 
-      # to  an array of integers.  Splits version string on "."
-      def to_integer_array(arg)
-        arr = case arg
-        when Array then arg
-        else arg.to_s.split('.')
-        end
-        arr.collect {|i| i.to_i}
-      end
+      end
+      
+      # A <=> comparison for versions.  compare_versions can take strings, 
+      # integers, or even arrays representing the parts of a version.
+      #
+      #   compare_versions("1.0.0", "0.9.9")          # => 1
+      #   compare_versions(1.1, 1.1)                  # => 0
+      #   compare_versions([0,9], [0,9,1])            # => -1
+      def compare_versions(a,b)
+        a, b = [a,b].collect {|item| to_integer_array(item) }
+        
+        # equalize the lengths of the integer arrays
+        d = b.length - a.length
+        case 
+        when d < 0 then b.concat Array.new(-d, 0)
+        when d > 0 then a.concat Array.new(d, 0)
+        end 
+      
+        a <=> b
+      end
+      
+      private
+      
+      # Converts an input argument (typically a string  or an array) 
+      # to  an array of integers.  Splits version string on "."
+      def to_integer_array(arg)
+        arr = case arg
+        when Array then arg
+        else arg.to_s.split('.')
+        end
+        arr.collect {|i| i.to_i}
+      end
       
     end
   end

data/lib/tap/task.rb

@@ -1,14 +1,58 @@
 module Tap
-  
-  # == Overview
-  #
-  # Tasks are the basic executable unit of Tap.  When an App executes
-  # a Task, the Task will be passed inputs which it then processes into
-  # results.  Tasks are joined into workflows using condition blocks  
-  # defining when a set of inputs are ready for execution, and where to
-  # pass results when the Task completes. Tasks fundamentally consist 
-  # of a condition_block, a process method, and an on_complete_block.
-  # 
+  # = Overview
+  #
+  # Tasks are the basic organizational unit of Tap.  Tasks provide
+  # a standard backbone for creating the working parts of an application
+  # by facilitating configuration, batched execution of methods, and 
+  # interaction with the command line.
+  #
+  # The functionality of Task is built from several base modules:
+  # - Tap::Support::Batchable
+  # - Tap::Support::Configurable
+  # - Tap::Support::Executable
+  #
+  # Tap::Workflow is built on the same foundations; the sectons on
+  # configuration and batching apply equally to Workflows as Tasks.
+  #
+  # === Task Definition
+  #
+  # Tasks are instantiated with a task block; when the task is run
+  # the block gets called with the enqued inputs.  As such, the block
+  # should specify the same number of inputs as you enque (plus the
+  # task itself, which is a standard input).
+  #
+  #   no_inputs = Task.new {|task| }
+  #   one_input = Task.new {|task, input| }
+  #   mixed_inputs = Task.new {|task, a, b, *args| }
+  #
+  #   no_inputs.enq
+  #   one_input.enq(:a)
+  #   mixed_inputs.enq(:a, :b)
+  #   mixed_inputs.enq(:a, :b, 1, 2, 3)
+  #
+  # Subclasses of Task specify executable code by overridding the process 
+  # method. In this case the number of enqued inputs should correspond to
+  # process (passing the task would be redundant).
+  #
+  #   class NoInput < Tap::Task
+  #     def process() end
+  #   end
+  #
+  #   class OneInput < Tap::Task
+  #     def process(input) end
+  #   end
+  #
+  #   class MixedInputs < Tap::Task
+  #     def process(a, b, *args) end
+  #   end
+  #
+  #   NoInput.new.enq
+  #   OneInput.new.enq(:a)
+  #   MixedInputs.new.enq(:a, :b)
+  #   MixedInputs.new.enq(:a, :b, 1, 2, 3)
+  #
+  # === Configuration 
+  #
   # Tasks are configurable.  By default each task will be configured
   # with the default class configurations, which can be set when the 
   # class is defined. 
@@ -19,516 +63,262 @@ module Tap
   #   end
   # 
   #   t = ConfiguredTask.new
-  #   t.config            # => {:one => 'one', :two => 'two'}
-  #  
-  # Tasks also have a name (based on the class name by default).  The
-  # task name is used as a relative filepath from application directories
-  # to assoicated files.  During initialization, the task name is used
-  # to lookup configurations from config_file.  Additional and overriding 
-  # configurations may be provided during initialization.
-  #
-  #   t.name              # => "configured_task"
-  #   t.app[:config]      # => "/path/to/app/config"
-  #   t.config_file       # => "/path/to/app/config/configured_task.yml"
-  # 
-  #   # [/path/to/app/config/example.yml]
-  #   # one: ONE
-  #  
-  #   t = ConfiguredTask.new "example", :three => 'three'
-  #   t.name              # => "example"
-  #   t.config_file       # => "/path/to/app/config/example.yml"
-  #   t.config            # => {:one => 'ONE', :two => 'two', :three => 'three'}
+  #   t.name                 # => "configured_task"
+  #   t.config               # => {:one => 'one', :two => 'two'}
   #
-  # === Batches
+  # Configurations can be validated or processed using an optional
+  # block.  Tap::Support::Validation pre-packages several common
+  # validation/processing blocks, and can be accessed through the
+  # class method 'c':
   #
-  # Tasks are designed to facilitate batch processing of inputs.  Each
-  # time a task queues inputs to itself, the inputs are collected into a 
-  # batch.  Upon execution, all inputs are passed to the task at once.  
-  # If the task is iterative (the default), then each of these inputs is 
-  # processed individually.  Otherwise, all inputs are processed as a single
-  # group:
+  #   class ValidatingTask < Tap::Task
+  #     # string config validated to be a string
+  #     config :string, 'str', &c.check(String)
   #
-  #   runlist = []
-  #   t1 = Task.new {|task, input| runlist << input}
-  #   t1.enq 1
-  #   t1.enq 2,3
-  #   t1.app.run
-  #   runlist            # => [1,2,3]
+  #     # integer config; string inputs are converted using YAML
+  #     config :integer, 1, &c.yaml(Integer)
+  #   end 
   #
-  #   runlist = []
-  #   t1.iterate = false
-  #   t1.enq 1
-  #   t1.enq 2,3
-  #   t1.app.run
-  #   runlist            # => [[1,2,3]]
+  #   t = ValidatingTask.new
+  #   t.string = 1           # => ValidationError
+  #   t.integer = 1.1        # => ValidationError
   #
-  # Additionally, tasks are designed to facilitate processing using a batch 
-  # of related tasks.  Often these batches consist of the same task class,
-  # but with a variety of configurations, but they can be assembled in other
-  # ways. When a task is queued, each task in the batch will be queued:
+  #   t.integer = "1"
+  #   t.integer == 1         # => true 
   #
-  #   runlist = []
-  #   t1 = Task.new {|task, input| runlist << input}
-  #   t1.batch                      # => [t1]
-  #   t2 = t1.create_batch_task            
-  #   t1.batch                      # => [t1, t2]
-  #   
-  #   t1.enq 1
-  #   t2.enq 2,3
-  #   t1.app.run
-  #   runlist                       # => [1,2,3, 1,2,3]        
-  #   
-  # Here runlist reflects that t1 and t2 were run in succession with the same [1,2,3] 
-  # inputs. Configuration batches are automatically generated when task.config_file 
-  # specifies an array of configurations; each configuration is translated into a 
-  # batched task.
+  # Tasks have a name that gets used as a relative filepath to find
+  # associated files (for instance config_file). By default the task 
+  # name is based on the task class, such that Tap::Task corresponds
+  # to 'tap/task'.  Custom names can be provided when a task is 
+  # initialized, as can additional and/or overriding configurations.
+  #
+  #   # [/path/to/app/config/example.yml]
+  #   # one: ONE
+  #  
+  #   t = ConfiguredTask.new "example", :three => 'three'
+  #   t.name                 # => "example"
+  #   t.app[:config]         # => "/path/to/app/config"
+  #   t.config_file          # => "/path/to/app/config/example.yml"
+  #   t.config               # => {:one => 'ONE', :two => 'two', :three => 'three'}
+  #
+  # Tasks can be assembled into batches that enque and execute 
+  # collectively. Batched tasks are automatically generated when a
+  # config_file specifies an array of configurations.
   #
   #   # [/path/to/app/config/batch.yml]
   #   # - one: ONE
   #   # - one: ANOTHER ONE
   #
   #   t = ConfiguredTask.new "batch"
-  #   t.batch.size        # => 2
+  #   t.batch.size           # => 2
   #   t1, t2 = t.batch
   #
-  #   t1.name             # => "batch"
-  #   t1.config_template  # => {:one => 'ONE'}
-  #   t1.config           # => {:one => 'ONE', :two => 'two'}
+  #   t1.name                # => "batch"
+  #   t1.config              # => {:one => 'ONE', :two => 'two'}
   #
-  #   t2.name             # => "batch"
-  #   t2.config_template  # => {:one => 'ANOTHER ONE'}
-  #   t2.config           # => {:one => 'ANOTHER ONE', :two => 'two'}
+  #   t2.name                # => "batch"
+  #   t2.config              # => {:one => 'ANOTHER ONE', :two => 'two'}
   #
-  # Task processes configuration files to make the definition of configuration 
-  # templates more DRY and powerful (see Tap::Support::Templater for more 
-  # details).  Here the default ConfiguredTask configurations are overridden
-  # by variations created by the variations! tag: 
-  # 
-  #   # [/path/to/app/config/template.yml]
-  #   # one: ONE
-  #   # variations!:
-  #   #   - two: TWO
-  #   #   - three: THREE
+  # === Batches
   #
-  #   t = ConfiguredTask.new "template"
-  #   t.batch.size        # => 2
-  #   t1, t2 = t.batch
+  # Tasks facilitate batch processing of inputs using batched tasks.  Often 
+  # a batch consists of the the same task class instantiated with a variety 
+  # of configurations.  Once batched, tasks enque together; when any one of 
+  # the tasks is enqued, the entire batch is enqued.
   #
-  #   t1.config           # => {:one => 'ONE', :two => 'TWO'}
-  #   t2.config           # => {:one => 'ONE', :two => 'two', :three => 'THREE'}
+  #   runlist = []
+  #   t1 = Task.new {|task, input| runlist << input}
+  #   t1.batch               # => [t1]
   #
-  # All together, these features make it easy to process a batch of inputs
-  # using a batch of configurations -- all encapsulated in a workflow-ready
-  # architecture.
+  #   t2 = t1.initialize_batch_obj            
+  #   t1.batch               # => [t1, t2]
+  #   t2.batch               # => [t1, t2]
+  #   
+  #   t1.enq 1
+  #   t2.enq 2
+  #   t1.app.run
   #
-  # == Non-Task Tasks!
+  #   runlist                # => [1,1,2,2]
   #
-  # The methods definining the essential behavior of a Task are encapsulated in 
-  # the Tap::Task::Base module.  Using this module, Non-Task classes can be defined, 
-  # and Non-Task objects extended to behave like Tasks; ie they can be enqued, run, 
-  # and incorporated into workflows.  
+  # Here runlist reflects that t1 and t2 were run in succession with the 1 
+  # input, and then the 2 input. 
   #
-  # See Tap::Task::Base for more details (esp for objects with a process method),
-  # as well as Tap::Support::Rake, which makes Rake tasks behave like Tap tasks.
+  # === Non-Task Tasks
   #
-  class Task < Monitor
-    write_inheritable_attribute(:configurations, Support::TaskConfiguration.new)  
-    class_inheritable_reader(:configurations)  
-
-    write_inheritable_attribute(:iterative, true)  
-    class_inheritable_reader(:iterative)
-
-    write_inheritable_attribute(:source_files, [])  
-    class_inheritable_reader(:source_files)
-
-    class << self
-      
-      # Currently an experimental way of identifying source files for TDoc
-      # documentation.
-      def source_file(arg) # :nodoc:
-        source_files << arg
-      end
-      
-      # Declares a configuration without any accessors.
-      #
-      # With no keys specified, sets config to make no accessors 
-      # for each new configuration.
-      def declare_config(*keys)
-        if keys.empty?
-          self.config_mode = :none 
-        else 
-          keys.each do |key|
-            configurations.declare(key, self)
-          end
-        end
-      end
-      
-      # Creates a configuration writer for the input keys.  Works like
-      # attr_writer, except the value is written to config, rather than
-      # a local variable.  In addition, the config will be validated
-      # using validate_config upon setting the value.
-      #
-      # With no keys specified, sets config to create config_writer 
-      # for each new configuration.
-      def config_writer(*keys)
-        if keys.empty?
-          self.config_mode = :config_writer 
-        else 
-          keys.each do |key|
-            configurations.declare(key, self)
-            define_config_writer(key)
-          end
-        end
-      end
-      
-      # Creates a configuration reader for the input keys.  Works like
-      # attr_reader, except the value is read from config, rather than
-      # a local variable.
-      #
-      # With no keys specified, sets config to create a config_reader 
-      # for each new configuration.
-      def config_reader(*keys)
-        if keys.empty?
-          self.config_mode = :config_reader 
-        else 
-          keys.each do |key|
-            configurations.declare(key, self)
-            define_config_reader(key)
-          end
-        end
-      end
-      
-      # Creates configuration accessors for the input keys.  Works like
-      # attr_accessor, except the value is read from and written to config, 
-      # rather than a local variable.
-      #
-      # With no keys specified, sets config to create a config_accessor 
-      # for each new configuration.
-      def config_accessor(*keys)
-        if keys.empty?
-          self.config_mode = :config_accessor 
-        else 
-          keys.each do |key|
-            configurations.declare(key, self)
-            define_config_reader(key)
-            define_config_writer(key)
-          end
-        end
-      end
+  # The essential behavior of a Task is expressed in the Tap::Task::Base 
+  # module.  Using this module, non-task classes can be made to behave like 
+  # tasks.  An even more fundamental module, Tap::Executable, allows any 
+  # method to behave in this manner.
+  #
+  # Configurations are specific to Task but batches are not.  Non-task 
+  # tasks can be batched.  Executable methods cannot be batched.
+  #
+  # See Tap::Task::Base and Tap::Support::Executable for more details as 
+  # well as Tap::Support::Rake::Task, which makes Rake[http://rake.rubyforge.org/] 
+  # tasks behave like Tap tasks.
+  class Task
+   
+    # Defines the essential behavior of a Task.  Using this module, 
+    # non-task classes can be made to behave like tasks; ie they can 
+    # be enqued, batched, and incorporated into workflows. 
+    module Base 
+      include Support::Executable
       
-      # Sets a class configuration.  Configurations are inherited, but can 
-      # be overridden or added in subclasses. Accessors are created by 
-      # default, but this behavior can be modified by use of the other
-      # config methods.  
-      #
-      #   class SampleTask < Tap::Task
-      #     config :key, 'value'
-      #     
-      #     config_reader
-      #     config :reader_only
-      #   end
-      #
-      #   t = SampleTask.new
-      #   t.respond_to?(:reader_only)         # => true
-      #   t.respond_to?(:reader_only=)        # => false
-      #
-      #   t.config               # => {:key => 'value', :reader_only => nil} 
-      #   t.key                  # => 'value'
-      #   t.key = 'another'
-      #   t.config               # => {:key => 'another', :reader_only => nil}
-      def config(key, value=nil, attributes={})
-        declare_config(key)
-        configurations.set(key, value, attributes)
-        
-        case config_mode
-        when nil, :config_accessor then config_accessor(key)
-        when :config_writer then config_writer(key)
-        when :config_reader then config_reader(key)
-        end
-      end
+      attr_reader :app
       
-      # Sets the default iteration behavior for a task class 
-      # to iterate inputs during task execution.  As a result,
-      # tasks will NOT execute without inputs.
-      def iterate
-        self.write_inheritable_attribute(:iterative, true)  
+      # Initializes obj to behave like a Task.  The input method will be
+      # called when obj is run by Tap::App.
+      def self.initialize(obj, method_name, app=App.instance)
+        obj.extend Base
+        obj.extend Support::Batchable
+        obj.instance_variable_set(:@app, app)
+        obj.instance_variable_set(:@batch, [])
+        obj.instance_variable_set(:@multithread, false)
+        obj.instance_variable_set(:@on_complete_block, nil)
+        obj.instance_variable_set(:@_method_name, method_name)
+        obj.initialize_batch_obj
+        obj
       end
     
-      # Sets the default iteration behavior for a task class 
-      # to not iterate inputs during task execution.  As a result,
-      # tasks can execute without inputs.
-      def do_not_iterate
-        self.write_inheritable_attribute(:iterative, false)  
+      # Enqueues self and self.batch to app with the inputs.  
+      # The number of inputs provided should match the number 
+      # of inputs specified by the arity of the _method_name method.
+      def enq(*inputs)
+        batch.each {|t| t.unbatched_enq(*inputs) }
+        self
       end
-
-      protected
-      
-      attr_accessor :config_mode
       
-      private
-      
-      def define_config_reader(key) # :nodoc:
-        define_method(key) do
-          config[key]
-        end
+      # Like enq, but only enques self and not self.batch.
+      def unbatched_enq(*inputs)
+        app.queue.enq(self, inputs)
       end
       
-      def define_config_writer(key) # :nodoc:
-        define_method("#{key}=") do |value|
-          config[key] = value
-          validate_config(key, value)
-          value
-        end
-      end
-    end
-    
-    # Tap::Task::Base encapsulates the methods definining the essential 
-    # behavior of a Task.  
-    module Base
-      attr_reader :app, :batch, :condition_block, :on_complete_block, :results
-      attr_accessor :multithread, :iterate
-    
-      # Creates a new Task with the specified attributes.
-      def self.extended(base)
-        base.extend MonitorMixin
+      alias :unbatched_on_complete :on_complete
       
-        base.instance_variable_set("@app", App.instance) if base.app.nil?
-        base.instance_variable_set("@batch", [base]) if base.batch.nil?
-        base.instance_variable_set("@results", []) if base.results.nil?
-        base.instance_variable_set("@condition_block", nil) if base.condition_block.nil?
-        base.instance_variable_set("@on_complete_block", nil) if base.on_complete_block.nil?
-        base.instance_variable_set("@multithread", false) if base.multithread.nil?
-        base.instance_variable_set("@iterate", false) if base.iterate.nil?
+      # Sets the on_complete_block for self and self.batch.
+      # Use unbatched_on_complete to set the on_complete_block
+      # for just self.
+      def on_complete(override=false, &block)
+        batch.each {|t| t.unbatched_on_complete(override, &block)}
+        self
       end
       
-      # Returns true if the batch size is greater than one 
-      # (the one being the current task itself).  
-      def batched?
-        batch.length > 1
-      end
-    
-      # Returns the index of the current task in batch.
-      def batch_index
-        batch.index(self)
-      end
-    
-      # Returns true if multithread is true.
-      #
-      # (NOTE -- multithreading is currently experimental!)
-      def multithread?
-        multithread
-      end
-    
-      # Returns true if iterate is true.  If iterate has not been set for the task, 
-      # then iterate? returns the value of the class iterative variable.
-      def iterate?
-        iterate
-      end
-        
-      # Sets a condition block for the task.  Raises an error if condition_block is 
-      # already set, unless override = true.
-      #
-      # Note that the block will recieve the audited_inputs of the task
-      # (see Audit for more information).
-      def condition(override=false, &block) # :yields: self, audited_inputs
-        raise "Condition for task already set: #{self}" unless condition_block.nil? || override
-        self.condition_block = block
-      end
-    
-      # Sets a block to execute when the task completes execution.  Raises an error 
-      # if on_complete_block is already set, unless override = true.
-      #
-      # Note that the block will recieve the results of the task, ie an array of 
-      # audited values and not values themselves (see Audit for more information).
-      def on_complete(override=false, &block) # :yields: results
-        raise "On complete for task already set: #{self}" unless on_complete_block.nil? || override
-        self.on_complete_block = block
-      end
-    
-      # Returns true if no condition block is specified, or the condition
-      # block evaluates to true with the given inputs.
-      def executable?(inputs)
-        condition_block ? condition_block.call(self, inputs) : true
-      end
-    
-      # Execute the actions associated with this task.  Returns an array of Audits; 
-      # one for each input value.  Raises an error if the task is not executable with 
-      # the inputs, and executes the on_complete block when finished.
-      #
-      # Execute is synchronized such that a task can only execute on one thread at a 
-      # time.
-      def execute(*inputs)
-        synchronize do
-          check_terminate
-          
-          audited_inputs = if iterate? 
-            Support::Audit.register(*inputs)
-          else
-            Support::Audit.merge(*inputs)
-          end
-          
-          self.results = nil
-          raise "Condition not met." unless executable?(audited_inputs)
-          
-          before_execute
-          begin
-            self.results = if iterate? 
-              audited_inputs.collect do |audited_input| 
-                on_execute(audited_input)
-              end
-            else
-              [on_execute(audited_inputs)]
-            end
-          rescue
-            on_execute_error($!)
-          end
-          after_execute
-        
-          on_complete_block.call(results) if on_complete_block
-          results
-        end
+      alias :unbatched_multithread= :multithread=
+      
+      # Sets the multithread for self and self.batch.  Use 
+      # unbatched_multithread= to set multithread for just self.
+      def multithread=(value)
+        batch.each {|t| t.unbatched_multithread = value }
+        self
       end
       
-      # Raises a TerminateError if the application is in state
-      # TERMINATE, as a mechanism to gracefully terminate threads.
-      #--
-      # Only occurs if the task is multithreaded.  
-      #++
-      #
-      # check_terminate is called before each execution, but can 
-      # be manually called at any time to provide a breakpoint
-      # in long executions.
+      # Raises a TerminateError if app.state == State::TERMINATE.
+      # check_terminate may be called at any time to provide a 
+      # breakpoint in long-running processes.
       def check_terminate
-        #if multithread? && app.state == App::State::TERMINATE
         if app.state == App::State::TERMINATE
           raise App::TerminateError.new
         end
-      end
-      
-      protected
-
-      attr_writer :app, :batch, :condition_block, :on_complete_block, :results
-      
-      # Hook to execute code before inputs are processed.
-      def before_execute() end
-    
-      # Hook for overridding the execution code that generates the 
-      # task results.  The input will be an audited version of the
-      # inputs array provided to execute, or, if iterate? is true, 
-      # an audited version of each individual input provided to 
-      # execute.  on_execute should return the audited_inputs.
-      #
-      # By default, on_execute sends the current value of the audited 
-      # input process and then records the output with self as the source.
-      #
-      # It is not advised to override the default on_execute unless 
-      # absolutely necessary.  Consider adjusting the behavior of
-      # process first.
-      def on_execute(audited_inputs) 
-        output = process(audited_inputs._current)
-        audited_inputs._record(self, output)
-      end
-      
-      # Hook to execute code after inputs are processed, but before the on_complete block.
-      def after_execute() end
-
-      # Hook to handle unhandled errors from processing inputs on a task level.  
-      # By default on_execute_error simply re-raises the unhandled error.
-      def on_execute_error(err)
-        raise err
-      end
+      end      
     end
     
     include Base
-   
-    attr_reader :name, :config, :config_template, :task_block
-
-    # Creates a new Task with the specified attributes.
-    def initialize(name=nil, config=nil, app=App.instance, &task_block)
-      super() # required for Monitor
-      
-      self.name = name.nil? ? self.class.to_s.underscore : name
-      self.app = app
-      
-      self.condition_block = nil
-      self.task_block = task_block
-      self.on_complete_block = nil
-      self.results = [] 
-      self.multithread = false 
-      self.iterate = self.class.iterative
-      self.batch = []
- 
-      # collect all configuration templates from the app
-      templates = []
-      app.config_templates(self.config_file).each do |template|
-        templates.concat make_config_templates(template)
-      end
-      
-      # be sure there is at least one template and
-      # add a task to batch for every template
-      templates << {} if templates.empty?
-      templates.each do |template|
-        self.create_batch_task(template, config)
-      end
-    end
+    include Support::Configurable
     
-    # Creates a batched task based on the config_template and overrides,
-    # and adds the task to batch.  The batched task will be a duplicate 
-    # of the current task but with new configurations.  
-    #
-    # This method can be overridden to initialize variables that are 
-    # specific to a batch task, for instance variables depending on
-    # batch_index.
-    def create_batch_task(config_template={}, overrides={})
-      task = (self.batch.empty? ? self : self.dup)
-      task.config_template = config_template.symbolize_keys
-      task.batch << task
-      task.config = overrides
-      task
-    end
+    attr_reader :task_block
     
-    # Returns the path to the configuration file used to make the task configuration
-    # templates.  By default this is the YAML file for the task name relative to the
-    # application config directory:
+    # Creates a new Task with the specified attributes.  
     #
-    #   t.app['config']         # => '/path/to/config'
-    #   t.name                  # => 'some/task'
-    #   t.config_file           # => '/path/to/config/some/task.yml'
+    # === Subclassing
+    # Batched tasks are generated by duplicating an existing instance, hence
+    # it is a good idea to set shared instance variables BEFORE calling super
+    # in a subclass initialize method.  Non-shared instance variables can be
+    # set by overriding the initialize_batch_obj method:
     #
-    def config_file
-      # since this is called during initialization before they
-      # are set, take care that this does not depend on batch,
-      # config, or config_template
-      app.filepath('config', self.name + ".yml")
-    end
-
-    # Configures the task with the given configuration overrides.  A Task has three
-    # configuration sources: the default class configurations, the config_template 
-    # loaded from config_file, and the inputs to this method. Configurations from these 
-    # sources are merged as:  default_config.merge(config_template).merge(overrides)
+    #   class SubclassTask < Tap::Task
+    #     attr_accessor :shared_variable, :instance_specific_variable
+    #
+    #     def initialize(*args)
+    #       @shared_variable = Object.new
+    #       super
+    #     end
+    #  
+    #     def initialize_batch_obj(*args)
+    #       task = super
+    #       task.instance_specific_variable = Object.new
+    #       task
+    #     end
+    #   end
     #
-    # Configurations are symbolized before they are merged.  If overrides is nil, then
-    # they will be treated as an empty hash.  All configurations are validated using
-    # validate_config.
-    def config=(overrides)
-      overrides = overrides.nil? ? {} : overrides.symbolize_keys 
-      @config = self.class.configurations.default.merge(config_template).merge(overrides)
-      self.config.each_pair {|key, value| validate_config(key, value) }
-      self.config
+    #   t1 = SubclassTask.new
+    #   t2 = t1.initialize_batch_obj
+    #   t1.shared_variable == t2.shared_variable                           # => true
+    #   t1.instance_specific_variable == t2.instance_specific_variable     # => false
+    #
+    def initialize(name=nil, config={}, app=App.instance, &task_block)
+      @task_block = (task_block == nil ? default_task_block : task_block)
+      @multithread = false
+      @on_complete_block = nil
+      @_method_name = :execute
+      super(name, config, app)
     end
     
-    # The method for processing inputs into outputs.  Override this method in
-    # subclasses to provide class-specific process logic.  By default the 
-    # input is passed to the task_block (provided during initialization).
-    # Simply returns the input if no task_block is set.
-    def process(input)
-      check_terminate
-      task_block.nil? ? input : task_block.call(self, input)
+    # Executes self with the given inputs.  Execute provides hooks for subclasses
+    # to insert standard execution code: before_execute, on_execute_error,
+    # and after_execute.  Override any/all of these methods as needed.
+    #
+    # Execute passes the inputs to process and returns the result.
+    def execute(*inputs)  
+      before_execute
+      begin
+        result = process(*inputs)
+      rescue
+        on_execute_error($!)
+      end
+      after_execute
+       
+      result
     end
     
-    # Enqueues self to the app queue with the inputs.  
-    def enq(*inputs)
-      app.queue.enq(self, *inputs)
+    # The method for processing inputs into outputs.  Override this method in
+    # subclasses to provide class-specific process logic.  The number of 
+    # arguments specified by process corresponds to the number of arguments
+    # the task should have when enqued.  
+    #
+    #   class TaskWithTwoInputs < Tap::Task
+    #     def process(a, b)
+    #       [b,a]
+    #     end
+    #   end
+    #
+    #   t = TaskWithTwoInputs.new
+    #   t.enq(1,2).enq(3,4)
+    #   t.app.run
+    #   t.app.results(t)         # => [[2,1], [4,3]]
+    #
+    # By default process passes self and the input(s) to the task_block   
+    # provided during initialization.  In this case the task block dictates  
+    # the number of arguments enq should receive.  Simply returns the inputs
+    # if no task_block is set.
+    #
+    #   # two arguments in addition to task are specified
+    #   # so this Task must be enqued with two inputs...
+    #   t = Task.new {|task, a, b| [b,a] }
+    #   t.enq(1,2).enq(3,4)
+    #   t.app.run
+    #   t.app.results(t)         # => [[2,1], [4,3]]
+    #
+    def process(*inputs)
+      return inputs if task_block == nil
+      inputs.unshift(self)
+      
+      arity = task_block.arity
+      n = inputs.length
+      unless n == arity || (arity < 0 && (-1-n) <= arity) 
+        raise ArgumentError.new("wrong number of arguments (#{n} for #{arity})")
+      end
+      
+      task_block.call(*inputs)
     end
 
     # Logs the inputs to the application logger (via app.log)
@@ -537,24 +327,28 @@ module Tap
       app.log(action, msg, level)
     end
     
+    # Returns self.name
+    def to_s
+      name
+    end
+    
     protected
-
-    attr_writer :name, :config_template, :task_block
     
-    # Hook to validate configurations.
-    def validate_config(key, value)
+    # Hook to set a default task block.  By default, nil.
+    def default_task_block
+      nil
     end
     
-    # Hook to provide class-specific processing of the config_file template
-    # (ie app.config_template(config_file)).  By default the template is 
-    # processed using Support::Templater.make_templates.
-    def make_config_templates(template)
-      Support::Templater.make_templates(template) 
-      # this would be a security hole... can't do it.
-      # if you can set :data then you could read 
-      # any accessible file.
-      #{ |filename| app.read(:data, filename) }
-    end
+    # Hook to execute code before inputs are processed.
+    def before_execute() end
+  
+    # Hook to execute code after inputs are processed.
+    def after_execute() end
 
+    # Hook to handle unhandled errors from processing inputs on a task level.  
+    # By default on_execute_error simply re-raises the unhandled error.
+    def on_execute_error(err)
+      raise err
+    end
   end
 end