bahuvrihi-tap 0.10.7 → 0.10.8

data/lib/tap/support/node.rb

@@ -5,15 +5,13 @@ module Tap
     class Node
       
       # An array of arguments used to instantiate
-      # the node, and to specify arguments enqued
-      # to the instance (when the node is directly
-      # enqued to a round... see input)
+      # the node
       attr_accessor :argv
       
       # The input or source for the node.  Inputs
-      # may be a Join, nil, or an Integer (indicating
-      # the node should be enqued to a round, with 
-      # inputs as specified in argv).
+      # may be a Join, nil, or an Integer.  An 
+      # Integer input indicates that the node should 
+      # be enqued to a round using argv as inputs.
       attr_accessor :input
       
       # The output for the node. Output may be a

data/lib/tap/support/parser.rb

@@ -4,6 +4,8 @@ autoload(:Shellwords, 'shellwords')
 module Tap
   module Support
     
+    # == Syntax
+    #
     # ==== Round Assignment
     # Tasks can be defined and set to a round using the following:
     #
@@ -23,7 +25,7 @@ module Tap
     # ==== Workflow Assignment
     # All simple workflow patterns except switch can be specified within
     # the parse syntax (switch is the exception because there is no good
-    # way to define a block from an array).  
+    # way to define the switch block).  
     #
     #   break      pattern       source(s)      target(s)
     #   --:        sequence      last           next
@@ -40,7 +42,7 @@ module Tap
     #   --(2,3,4)     last.sync_merge(2,3,4)
     #
     # Note how all of the bracketed styles behave similarly; they are
-    # parsed with essentially the same code, only reversing the source
+    # parsed with essentially the same code, but reverse the source
     # and target in the case of merges.
     #
     # Here a and b are sequenced inline.  Task c is assigned to no 
@@ -246,6 +248,55 @@ module Tap
           end
           options
         end
+        
+        # Parses an arg hash into a schema argv.  An arg hash is a hash
+        # using numeric keys to specify the [row][col] in a two-dimensional
+        # array where a set of values should go.  Breaks are added between
+        # rows (if necessary) and the array is collapsed to yield the
+        # argv:
+        #
+        #   argh = {
+        #     0 => {
+        #       0 => 'a',
+        #       1 => ['b', 'c']},
+        #     1 => 'z'
+        #   }
+        #   parse_argh(argh)    # => ['--', 'a', 'b', 'c', '--', 'z']
+        # 
+        # Non-numeric keys are converted to integers using to_i and
+        # existing breaks (such as workflow breaks) occuring at the
+        # start of a row are preseved.
+        #
+        #   argh = {
+        #     '0' => {
+        #       '0' => 'a',
+        #       '1' => ['b', 'c']},
+        #     '1' => ['--:', 'z']
+        #   }
+        #   parse_argh(argh)    # => ['--', 'a', 'b', 'c', '--:', 'z']
+        #
+        def parse_argh(argh)
+          rows = []
+          argh.each_pair do |row, values|
+            if values.kind_of?(Hash)
+              arry =  []
+              values.each_pair {|col, value| arry[col.to_i] = value }
+              values = arry
+            end
+
+            rows[row.to_i] = values
+          end
+          
+          argv = []
+          rows.each do |row|
+            row = [row].flatten.compact
+            if row.empty? || row[0] !~ BREAK
+              argv << '--'
+            end
+            argv.concat row
+          end
+          argv
+        end
       end
       
       include Utils
@@ -266,7 +317,8 @@ module Tap
       # arguments.
       #
       # Parse is non-destructive to argv.  If a string argv is provided, parse
-      # splits it into an array using Shellwords.
+      # splits it into an array using Shellwords; if a hash argv is provided,
+      # parse converts it to an array using Parser::Utils#parse_argh.
       #
       def parse(argv)
         parse!(argv.kind_of?(String) ? argv : argv.dup)
@@ -274,7 +326,12 @@ module Tap
 
       # Same as parse, but removes parsed args from argv.
       def parse!(argv)
-        argv = Shellwords.shellwords(argv) if argv.kind_of?(String)
+        argv = case argv
+        when Array then argv
+        when String then Shellwords.shellwords(argv) 
+        when Hash then parse_argh(argv)
+        else argv
+        end
         argv.unshift('--')
         
         escape = false
@@ -346,10 +403,10 @@ module Tap
       protected
       
       # The index of the node currently being parsed.
-      attr_accessor :current_index
+      attr_accessor :current_index # :nodoc:
       
       # Returns current_index-1, or raises an error if current_index < 1.
-      def previous_index
+      def previous_index # :nodoc:
         raise ArgumentError, 'there is no previous index' if current_index < 1
         current_index - 1
       end

data/lib/tap/support/schema.rb

@@ -243,9 +243,18 @@ module Tap
         end
         
         # instantiate and reconfigure globals
+        instances = []
         globals.each do |node|
-          task, args = tasks[node]
-          task.class.instance.reconfigure(task.config.to_hash)
+          task, args = tasks.delete(node)
+          instance = task.class.instance
+          
+          if instances.include?(instance)
+            raise "global specified multple times: #{instance}"
+          end
+          
+          instance.reconfigure(task.config.to_hash)
+          instance.enq(*args)
+          instances << instance
         end
 
         # build the workflow

data/lib/tap/support/shell_utils.rb

@@ -4,8 +4,7 @@ module Tap
   module Support
     # Provides several shell utility methods for calling programs.
     #
-    # == Windows
-    # A couple warnings when running shell commands in the MSDOS prompt on Windows.  
+    # == Windows 
     # MSDOS has command line length limits specific to the version of Windows being
     # run (from http://www.ss64.com/nt/cmd.html):
     #
@@ -13,9 +12,8 @@ module Tap
     # Windows 2000::  2046 characters
     # Windows XP:: 8190 characters
     #
-    # No word on more recent versions of Windows.  Commands longer than these limits
-    # fail, usually with something like: 'the input line is too long'
-    #
+    # Commands longer than these limits fail, usually with something like: 'the input
+    # line is too long'
     module ShellUtils
       
       module_function

data/lib/tap/support/string_ext.rb

@@ -0,0 +1,60 @@
+module Tap
+  module Support
+    
+    # StringExt provides two common string transformations, camelize and
+    # underscore. StringExt is automatically included in String.
+    #
+    # Both methods are directly taken from the ActiveSupport {Inflections}[http://api.rubyonrails.org/classes/ActiveSupport/CoreExtensions/String/Inflections.html]
+    # module.  StringExt should not cause conflicts if ActiveSupport is
+    # loaded alongside Tap.
+    #
+    # ActiveSupport is distributed with an MIT-LICENSE:
+    #
+    #   Copyright (c) 2004-2008 David Heinemeier Hansson
+    # 
+    #   Permission is hereby granted, free of charge, to any person obtaining a copy of this software and 
+    #   associated documentation files (the "Software"), to deal in the Software without restriction, 
+    #   including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, 
+    #   and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, 
+    #   subject to the following conditions:
+    # 
+    #   The above copyright notice and this permission notice shall be included in all copies or substantial 
+    #   portions of the Software.
+    # 
+    #   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 
+    #   LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN 
+    #   NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+    #   WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+    #   SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+    #
+    module StringExt
+      
+      # camelize converts self to UpperCamelCase. If the argument to 
+      # camelize is set to :lower then camelize produces lowerCamelCase.
+      # camelize will also convert '/' to '::' which is useful for
+      # converting paths to namespaces.
+      def camelize(first_letter = :upper)
+        case first_letter
+        when :upper then self.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+        when :lower then self.first + camelize[1..-1]
+        end
+      end
+      
+      # The reverse of camelize. Makes an underscored, lowercase form 
+      # from self.  underscore will also change '::' to '/' to convert 
+      # namespaces to paths.
+      def underscore
+        self.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+      end
+      
+    end
+  end
+end
+
+class String # :nodoc:
+  include Tap::Support::StringExt
+end

data/lib/tap/support/tdoc.rb

@@ -84,7 +84,7 @@ module Tap
     # Now execute the rake task like:
     #
     #   % rake rdoc
-    #
+    #--
     # === Implementation
     # RDoc is a beast to utilize in a non-standard way. One way to make RDoc parse unexpected
     # flags like 'config' or 'config_attr' is to use the '--accessor' option (see 'rdoc --help' or 
@@ -134,7 +134,7 @@ module Tap
     
       # Encasulates information about the configuration.  Designed to be utilized
       # by the TDocHTMLGenerator as similarly as possible to standard attributes.
-      class ConfigAttr < RDoc::Attr
+      class ConfigAttr < RDoc::Attr # :nodoc:
         # Contains the actual declaration for the config attribute. ex:  "c [:key, 'value']      # comment"
         attr_accessor :config_declaration, :default
         

data/lib/tap/support/templater.rb

@@ -5,10 +5,9 @@ module Tap
   module Support
     
     # Templater is a convenience class for creating ERB templates.  As
-    # an OpenStruct, attributes can be assigned/unassigned at will to
-    # a Templater.  When the template is built, all the method of 
-    # Templater (and hence all the assigned attributes) are available
-    # in the template.
+    # a subclass of OpenStruct, attributes can be assigned/unassigned
+    # directly.  When the template is built, all the method of 
+    # Templater (and hence all the assigned attributes) are available.
     #
     #   t = Templater.new( "key: <%= value %>")
     #   t.value = "default"
@@ -23,16 +22,14 @@ module Tap
     #
     # Templater hooks into the ERB templating mechanism by providing itself 
     # as the ERB output target (_erbout).  ERB concatenates each line of an 
-    # ERB template to _erbout, as can be seen when you look at the src code 
-    # evaluated by ERB:
+    # ERB template to _erbout, as can be seen here:
     #
     #   e = ERB.new("<%= 1 + 2 %>")
     #   e.src                   # => "_erbout = ''; _erbout.concat(( 1 + 2 ).to_s); _erbout"
     #
-    # By setting itself as _erbout, instances of Templater can redirect the 
-    # output to a temporary target which can then be used in string 
-    # transformations.  For example, redirection allows indentation of 
-    # nested content:
+    # By setting itself as _erbout, instances of Templater can redirect 
+    # output to a temporary target and perform string transformations.  
+    # For example, redirection allows indentation of nested content:
     #
     #   template = %Q{
     #   # Un-nested content
@@ -62,12 +59,17 @@ module Tap
         # yamlize converts the object to YAML (using to_yaml), omitting
         # the header and final newline:
         #
-      	#   {'key' => 'value'}.to_yaml           # => "--- \nkey: value\n"
-      	#   yamlize {'key' => 'value'}           # => "key: value"
+        #   {'key' => 'value'}.to_yaml           # => "--- \nkey: value\n"
+        #   yamlize {'key' => 'value'}           # => "key: value"
         def yamlize(object)
           object == nil ? "~" : YAML.dump(object)[4...-1].strip
         end
         
+        # Comments out the string.
+        def comment(str)
+          str.split("\n").collect {|line| "# #{line}" }.join("\n")
+        end
+        
         # Nest the return of the block in the nesting lines.
         #
         #  nest([["\nmodule Some", "end\n"],["module Nested", "end"]]) { "class Const\nend" }
@@ -117,6 +119,12 @@ module Tap
         end
       end
       
+      class << self
+        def build(template,  attributes={})
+          new(template, attributes).build
+        end
+      end
+      
       include Utils
       
       # Initialized a new Templater.  An ERB or String may be provided as the
@@ -124,8 +132,10 @@ module Tap
       # ERB with a trim_mode of "<>".
       def initialize(template, attributes={})
         @template = case template
-        when ERB 
-          if template.instance_variable_get(:@src).index('_erbout =') != 0
+        when ERB
+          # matching w/wo the coding effectively checks @src
+          # across ruby versions (encoding appears in 1.9)
+          if template.instance_variable_get(:@src) !~ /^(#coding:US-ASCII\n)?_erbout =/
             raise ArgumentError, "Templater does not work with ERB templates where eoutvar != '_erbout'"
           end
           template
@@ -170,7 +180,11 @@ module Tap
       
       # Build the template.  All methods of self will be 
       # accessible in the template.
-      def build
+      def build(attrs={})
+        attrs.each_pair do |key, value|
+          send("#{key}=", value)
+        end
+        
         @template.result(binding)
         @_erbout
       end

data/lib/tap/support/validation.rb

@@ -4,9 +4,9 @@ module Tap
   module Support
     
     # Validation generates blocks for common validations and transformations of 
-    # configurations set through Configurable.  In general these blocks allow
-    # configurations to be set to objects of a particular class, or to a string
-    # that can be loaded as YAML into such an object.
+    # configurations set through Configurable.  In general these blocks load
+    # string inputs as YAML and valdiate the results; non-string inputs are
+    # simply validated.
     #
     #   integer = Validation.integer
     #   integer.class             # => Proc
@@ -23,7 +23,6 @@ module Tap
     #
     # This syntax plays well with RDoc, which otherwise gets jacked 
     # when you do it all in one step.
-    #++
     module Validation
       
       # Raised when Validation blocks fail.
@@ -204,9 +203,11 @@ module Tap
       def boolean(); BOOLEAN; end
       BOOLEAN = yamlize_and_check(true, false, nil)
       
+      # Same as boolean.
       def switch(); SWITCH; end
       SWITCH = yamlize_and_check(true, false, nil)
       
+      # Same as boolean.
       def flag(); FLAG; end
       FLAG = yamlize_and_check(true, false, nil)
 
@@ -229,13 +230,20 @@ module Tap
       def array_or_nil(); ARRAY_OR_NIL; end
       ARRAY_OR_NIL = yamlize_and_check(Array, nil)
       
+      # Returns a block that checks the input is an array.
+      # If the input is a string the string is split along
+      # commas and each value yamlized into an array.
+      #
+      #   list.class                # => Proc
+      #   list.call([1,2,3])        # => [1,2,3]
+      #   list.call('1,2,3')        # => [1,2,3]
+      #   list.call('str')          # => ['str']
+      #   list.call(nil)            # => ValidationError
+      #
       def list(); LIST; end
       list_block = lambda do |input|
         if input.kind_of?(String)
-          input = case processed_input = yamlize(input)
-          when Array then processed_input
-          else input.split(/,/).collect {|arg| yamlize(arg) }
-          end
+          input = input.split(/,/).collect {|arg| yamlize(arg) }
         end
         
         validate(input, [Array])
@@ -438,10 +446,11 @@ module Tap
         TIME
       end
       
-      TIME = lambda do |input|
+      time_block = lambda do |input|
         input = Time.parse(input) if input.kind_of?(String)
         validate(input, [Time])
       end
+      TIME = time_block
       
       # Same as time but allows nil:
       #
@@ -454,7 +463,7 @@ module Tap
         TIME_OR_NIL
       end
       
-      TIME_OR_NIL = lambda do |input|
+      time_or_nil_block = lambda do |input|
         input = case input
         when nil, '~' then nil
         when String then Time.parse(input)
@@ -462,7 +471,9 @@ module Tap
         end
         
         validate(input, [Time, nil])
-      end
+      end 
+      TIME_OR_NIL = time_or_nil_block
+      
     end
   end
 end

data/lib/tap/task.rb

@@ -1,5 +1,7 @@
 require 'tap/support/executable'
 require 'tap/support/lazydoc/method'
+require 'tap/support/lazydoc/definition'
+require 'tap/support/intern'
 autoload(:OptionParser, 'optparse')
 
 module Tap
@@ -106,7 +108,7 @@ module Tap
   # parent task, although they can be manually assembled using Task.batch.
   #
   #   app = Tap::App.instance
-  #   t1 = Tap::Task.new(:key => 'one') do |task, input| 
+  #   t1 = Tap::Task.intern(:key => 'one') do |task, input| 
   #     input + task.config[:key]
   #   end
   #   t1.batch               # => [t1]
@@ -161,64 +163,43 @@ module Tap
     include Support::Executable
     
     class << self
-      # Returns the default name for the class: to_s.underscore
-      attr_accessor :default_name
-
       # Returns class dependencies
       attr_reader :dependencies
       
+      # Returns the default name for the class: to_s.underscore
+      attr_writer :default_name
+      
+      def default_name
+        # lazy-setting default_name like this (rather than
+        # within inherited, for example) is an optimization
+        # since many subclass operations end up setting
+        # default_name themselves.
+        @default_name ||= to_s.underscore
+      end
+      
+      # Returns an instance of self; the instance is a kind of 'global'
+      # instance used in class-level dependencies.  See depends_on.
+      def instance
+        @instance ||= new
+      end
+      
       def inherited(child)
         unless child.instance_variable_defined?(:@source_file)
           caller.first =~ Support::Lazydoc::CALLER_REGEXP
           child.instance_variable_set(:@source_file, File.expand_path($1)) 
         end
 
-        child.instance_variable_set(:@default_name, child.to_s.underscore)
         child.instance_variable_set(:@dependencies, dependencies.dup)
         super
       end
       
-      #--
-      # use with caution... should reset dependencies?
-      attr_writer :instance
-      
-      # Returns an instance of self; the instance is a kind of 'global'
-      # instance used in class-level dependencies.  See depends_on.
-      def instance
-        @instance ||= new
-      end
-      
-      # Generates or updates the specified subclass of self.
-      def subclass(const_name, configs={}, dependencies=[], options={}, &block)
-        #
-        # Lookup or create the subclass constant. 
-        #
-        
-        current, constants = const_name.to_s.constants_split
-        subclass = if constants.empty?
-          # The constant exists; validate the constant is a subclass of self.
-          unless current.kind_of?(Class) && current.ancestors.include?(self)
-            raise ArgumentError, "#{current} is already defined and is not a subclass of #{self}!"
-          end
-          current
-        else
-          # Generate the nesting module
-          subclass_const = constants.pop
-          constants.each {|const| current = current.const_set(const, Module.new)}
-
-          # Create and set the subclass constant
-          current.const_set(subclass_const, Class.new(self))
+      def intern(*args, &block)
+        instance = new(*args)
+        if block_given?
+          instance.extend Support::Intern
+          instance.process_block = block
         end
-        
-        #
-        # Define the subclass
-        #
-        
-        subclass.define_configurations(configs)
-        subclass.define_dependencies(dependencies)
-        subclass.define_process(block) if block_given?
-        subclass.default_name = subclass.to_s.underscore
-        subclass
+        instance
       end
       
       # Parses the argv into an instance of self and an array of arguments (implicitly
@@ -300,10 +281,7 @@ module Tap
         end
         obj.reconfigure(path_configs).reconfigure(argv_config)
         
-        # recollect arguments
-        argv = (argv + use_args).collect {|str| str =~ /\A---\s*\n/ ? YAML.load(str) : str }
-
-        [obj, argv]
+        [obj, (argv + use_args)]
       end
       
       def execute(argv=ARGV)
@@ -338,77 +316,141 @@ module Tap
         Tap::Support::Templater.new(DEFAULT_HELP_TEMPLATE, :task_class => self).build
       end
       
+      protected
+      
       # Sets a class-level dependency.  When task class B depends_on another task 
       # class A, instances of B are initialized to depend on A.instance, with the
       # specified arguments.  Returns self.
-      def depends_on(dependency_class, *args)
-        unless dependency_class.respond_to?(:instance)
-          raise ArgumentError, "dependency_class does not respond to instance: #{dependency_class}"
+      def depends_on(name, dependency_class)
+        unless dependencies.include?(dependency_class)
+          dependencies << dependency_class
         end
-        (dependencies << [dependency_class, args]).uniq!
-        self
-      end
-      
-      protected
-      
-      def dependency(name, dependency_class, *args)
-        depends_on(dependency_class, *args)
-
+        
+        # returns the resolved result of the dependency
         define_method(name) do
-          index = app.dependencies.index(dependency_class.instance, args)
-          app.dependencies.resolve([index])
-          app.dependencies.results[index]._current
+          instance = dependency_class.instance
+          instance.resolve
+          instance._result._current
         end
         
         public(name)
+        self
       end
       
-      def define(name, klass=Tap::Task, &block)
-        instance_var = "@#{name}".to_sym
+      # Defines a task subclass with the specified configurations and process block.
+      # During initialization the subclass is instantiated and made accessible 
+      # through a reader by the specified name.  
+      #
+      # Defined tasks may be configured during initialization, through config, or 
+      # directly through the instance; in effect you get tasks with nested configs 
+      # which greatly facilitates workflows.  Indeed, defined tasks are often 
+      # joined in the workflow method.
+      #
+      #   class AddALetter < Tap::Task
+      #     config :letter, 'a'
+      #     def process(input); input << letter; end
+      #   end
+      #
+      #   class AlphabetSoup < Tap::Task
+      #     define :a, AddALetter, {:letter => 'a'}
+      #     define :b, AddALetter, {:letter => 'b'}
+      #     define :c, AddALetter, {:letter => 'c'}
+      #
+      #     def workflow
+      #       a.sequence(b, c)
+      #     end
+      # 
+      #     def process
+      #       a.execute("")
+      #     end
+      #   end
+      #
+      #   AlphabetSoup.new.process            # => 'abc'
+      #
+      #   i = AlphabetSoup.new(:a => {:letter => 'x'}, :b => {:letter => 'y'}, :c => {:letter => 'z'})
+      #   i.process                           # => 'xyz'
+      #
+      #   i.config[:a] = {:letter => 'p'}
+      #   i.config[:b][:letter] = 'q'
+      #   i.c.letter = 'r'
+      #   i.process                           # => 'pqr'
+      #
+      # ==== Usage
+      #
+      # Define is basically the equivalent of:
+      #
+      #   class Sample < Tap::Task
+      #     Name = baseclass.subclass(config, &block)
+      #     
+      #     # accesses an instance of Name
+      #     attr_reader :name
+      #
+      #     # register name as a config, but with a
+      #     # non-standard reader and writer
+      #     config :name, {}, {:reader => :name_config, :writer => :name_config=}.merge(options)
+      #
+      #     # reader for name.config
+      #     def name_config; ...; end
+      #
+      #     # reconfigures name with input
+      #     def name_config=(input); ...; end
+      #
+      #     def initialize(*args)
+      #       super
+      #       @name = Name.new(config[:name])
+      #     end
+      #   end
+      #
+      # Note the following:
+      # * define will set a constant like name.camelize
+      # * the block defines the process method in the subclass
+      # * three methods are created by define: name, name_config, name_config=
+      #
+      def define(name, baseclass=Tap::Task, configs={}, options={}, &block)
+        # define the subclass
+        const_name = options.delete(:const_name) || name.to_s.camelize
+        subclass = const_set(const_name, Class.new(baseclass))
+        subclass.default_name = name.to_s
         
-        define_method(name) do |*args|
-          raise ArgumentError, "wrong number of arguments (#{args.length} for 1)" if args.length > 1
-          
-          instance_name = args[0] || name
-          instance_variable_set(instance_var, {}) unless instance_variable_defined?(instance_var)
-          instance_variable_get(instance_var)[instance_name] ||= config_task(instance_name, klass, &block)
+        configs.each_pair do |key, value|
+          subclass.send(:config, key, value)
         end
         
-        define_method("#{name}=") do |input|
-          input = {name => input} unless input.kind_of?(Hash)
-          instance_variable_set(instance_var, input)
+        if block_given?
+          subclass.send(:define_method, :process, &block)
         end
         
-        public(name, "#{name}=")
-      end
-      
-      def define_configurations(configs)
-        case configs
-        when Hash
-          # hash configs are simply added as default configurations
-          attr_accessor(*configs.keys)
-          configs.each_pair do |key, value|
-            configurations.add(key, value)
-          end
-          public(*configs.keys)
-        when Array
-          # array configs define configuration methods
-          configs.each do |method, key, value, opts, config_block| 
-            send(method, key, value, opts, &config_block)
+        # define methods
+        instance_var = "@#{name}".to_sym
+        reader = (options[:reader] ||= "#{name}_config".to_sym)
+        writer = (options[:writer] ||= "#{name}_config=".to_sym)
+        
+        attr_reader name
+        
+        define_method(reader) do
+          # return the config for the instance
+          instance_variable_get(instance_var).config
+        end
+        
+        define_method(writer) do |value|
+          # initialize or reconfigure the instance of subclass
+          if instance_variable_defined?(instance_var) 
+            instance_variable_get(instance_var).reconfigure(value)
+          else
+            instance_variable_set(instance_var, subclass.new(value))
           end
-        else 
-          raise ArgumentError, "cannot define configurations from: #{configs}"
         end
-      end
-      
-      def define_dependencies(dependencies)
-        dependencies.each do |name, dependency_class, args|
-          dependency(name, dependency_class, *(args ? args : []))
-        end if dependencies
-      end
-      
-      def define_process(block)
-        send(:define_method, :process, &block)
+        public(name, reader, writer)
+        
+        # add the configuration
+        if options[:desc] == nil
+          caller[0] =~ Support::Lazydoc::CALLER_REGEXP
+          desc = Support::Lazydoc.register($1, $3.to_i - 1, Support::Lazydoc::Definition)
+          desc.subclass = subclass
+          options[:desc] = desc
+        end
+        
+        configurations.add(name, subclass.configurations.instance_config, options)
       end
     end
     
@@ -423,20 +465,15 @@ module Tap
     # Currently names may be any object.  Audit makes use of name
     # via to_s, as does app when figuring configuration filepaths. 
     attr_accessor :name
-    
-    # The task block provided during initialization.  
-    attr_reader :task_block
 
     # Initializes a new instance and associated batch objects.  Batch
     # objects will be initialized for each configuration template 
     # specified by app.each_config_template(config_file) where 
     # config_file = app.config_filepath(name).  
-    def initialize(config={}, name=nil, app=App.instance, &task_block)
+    def initialize(config={}, name=nil, app=App.instance)
       super()
 
       @name = name || self.class.default_name
-      @task_block = (task_block == nil ? default_task_block : task_block)
-      
       @app = app
       @_method_name = :execute_with_callbacks
       @on_complete_block = nil
@@ -444,15 +481,17 @@ module Tap
       @batch = [self]
       
       case config
-      when Support::InstanceConfiguration 
-        @config = config
+      when Support::InstanceConfiguration
+        # update is prudent to ensure all configs have an input
+        # (and hence, all configs will be initialized)
+        @config = config.update(self.class.configurations)
         config.bind(self)
       else 
         initialize_config(config)
       end
       
-      self.class.dependencies.each do |task_class, args|
-        depends_on(task_class.instance, *args)
+      self.class.dependencies.each do |dependency_class|
+        depends_on(dependency_class.instance)
       end
       
       workflow
@@ -492,29 +531,9 @@ module Tap
     #   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]]
-    #
+    # By default, process simply returns the inputs.
     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)
+      inputs
     end
     
     # Logs the inputs to the application logger (via app.log)
@@ -522,15 +541,6 @@ module Tap
       # TODO - add a task identifier?
       app.log(action, msg, level)
     end
-
-    # 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 app.state == App::State::TERMINATE
-        raise App::TerminateError.new
-      end
-    end
     
     # Returns self.name
     def to_s
@@ -544,12 +554,7 @@ module Tap
     end
     
     protected
-    
-    # Hook to set a default task block.  By default, nil.
-    def default_task_block
-      nil
-    end
-    
+
     # Hook to define a workflow for defined tasks.
     def workflow
     end
@@ -580,11 +585,5 @@ module Tap
       result
     end
     
-    def config_task(name, klass=Tap::Task, &block)
-      configs = config[name] || {}
-      raise ArgumentError, "config '#{name}' is not a hash" unless configs.kind_of?(Hash)
-      klass.new(configs, name, &block)
-    end
-    
   end
 end