bahuvrihi-tap 0.11.2 → 0.12.0

data/lib/tap/support/constant_manifest.rb

@@ -4,18 +4,24 @@ require 'tap/support/constant'
 module Tap
   module Support
     
+    # :startdoc:::-
+    #
     # ConstantManifest builds a manifest of Constant entries using Lazydoc.
-    # The idea is that Lazydoc can find files with resouces of a specific type
-    # (ex tasks) and Constant can reference those resouces and load them as 
-    # necessary. ConstantManifest registers paths so that they may be lazily
-    # scanned when searching for a specific resource.
+    #
+    # Lazydoc can quickly scan files for constant attributes, and thereby
+    # identify constants based upon a flag like the '::manifest' attribute used
+    # to identify task classes.  ConstantManifest registers paths that will be
+    # scanned for a specific resource, and lazily builds a manifest of Constant
+    # references to load them as necessary.
+    # 
+    # :startdoc:::+
     class ConstantManifest < Support::Manifest
       
-      # The attribute identifying resources in a file
+      # The attribute identifying constants in a file
       attr_reader :const_attr
       
-      # Registered [root, [paths]] pairs that will be searched
-      # for the const_attr
+      # An array of registered [root, [paths]] pairs
+      # that will be searched for const_attr
       attr_reader :search_paths
       
       # The current index of search_paths
@@ -24,7 +30,8 @@ module Tap
       # The current index of paths
       attr_reader :path_index
       
-      # Initializes a new ConstantManifest
+      # Initializes a new ConstantManifest that will identify constants
+      # using the specified constant attribute.
       def initialize(const_attr)
         @const_attr = const_attr
         @search_paths = []
@@ -95,23 +102,19 @@ module Tap
       # filepath from path_root to path.
       def resolve(path_root, path)
         entries = []
-        lazydoc = nil
+        document = nil
         
-        Lazydoc.scan(File.read(path), const_attr) do |const_name, attr_key, comment|
-          if lazydoc == nil
-            lazydoc = Lazydoc[path]
-            
-            if lazydoc.default_const_name.empty?
-              relative_path = Root.relative_filepath(path_root, path).chomp(File.extname(path))
-              lazydoc.default_const_name = relative_path.camelize
-            end
+        Lazydoc::Document.scan(File.read(path), const_attr) do |const_name, key, value|
+          if document == nil
+            relative_path = Root.relative_filepath(path_root, path).chomp(File.extname(path))
+            document = Lazydoc.register_file(path, relative_path.camelize)
           end
           
-          if const_name.empty? 
-            const_name = lazydoc.default_const_name
-          end
+          const_name = document.default_const_name if const_name.empty? 
+          comment = Lazydoc::Subject.new(nil, document)
+          comment.value = value
           
-          lazydoc[const_name][attr_key] = comment
+          document[const_name][key] = comment
           entries << Constant.new(const_name, path)
         end
         

data/lib/tap/support/dependency.rb

@@ -12,7 +12,7 @@ module Tap
         base.instance_variable_set(:@_result, nil)
       end
       
-      # Conditional _execute; only calls _method_name if
+      # Conditional _execute; only calls method_name if
       # resolved? is false (thus assuring self will only
       # be executed once).
       #

data/lib/tap/support/executable.rb

@@ -10,7 +10,7 @@ module Tap
       attr_reader :app
       
       # The method called during _execute
-      attr_reader :_method_name
+      attr_reader :method_name
     
       # The block called when _execute completes
       attr_reader :on_complete_block
@@ -28,7 +28,7 @@ module Tap
       def self.initialize(obj, method_name, app=App.instance, batch=[], dependencies=[], &on_complete_block)
         obj.extend Executable
         obj.instance_variable_set(:@app, app)
-        obj.instance_variable_set(:@_method_name, method_name)
+        obj.instance_variable_set(:@method_name, method_name)
         obj.instance_variable_set(:@on_complete_block, on_complete_block)
         obj.instance_variable_set(:@dependencies, dependencies)
         obj.instance_variable_set(:@batch, batch)
@@ -37,10 +37,11 @@ module Tap
         obj
       end
       
-      # Initializes a new batch object and adds the object to batch.
-      # The object will be a duplicate of self.  (Note this method
-      # can raise an error for objects that don't support dup, 
-      # notably Method objects generated by Object#_method).
+      # Initializes a new batch object and adds the object to batch. The object
+      # will be a duplicate of self.  
+      #
+      # Note this method can raise an error for objects that don't support dup, 
+      # notably Method objects generated by Object#_method.
       def initialize_batch_obj
         obj = self.dup
         
@@ -48,7 +49,7 @@ module Tap
           batch << obj
           obj
         else
-          Executable.initialize(obj, _method_name, app, batch, dependencies, &on_complete_block)
+          Executable.initialize(obj, method_name, app, batch, dependencies, &on_complete_block)
         end
       end
       
@@ -125,7 +126,7 @@ module Tap
       
       # Enqueues each member of batch (and implicitly self) to app with the
       # inputs. The number of inputs provided should match the number of
-      # inputs for the _method_name method.
+      # inputs for the method_name method.
       def enq(*inputs)
         batch.each do |executable| 
           executable.unbatched_enq(*inputs)
@@ -193,10 +194,10 @@ module Tap
       end
 
       # Sets a switch workflow pattern for self.  When _execute completes, 
-      # switch yields the audited result to the block which should return
-      # the index of the target to enque with the results. No target will 
-      # be enqued if the index is false or nil; an error is raised if no 
-      # target can be found for the specified index. See Joins::Switch.
+      # switch yields the audited result to the block and the block should
+      # return the index of the target to enque with the results. No target
+      # will be enqued if the index is false or nil.  An error is raised if
+      # no target can be found for the specified index. See Joins::Switch.
       def switch(*targets, &block) # :yields: _result
         Joins::Switch.join(self, targets, &block)
       end
@@ -236,53 +237,34 @@ module Tap
         self
       end
       
-      # Auditing method call.  Resolves dependencies, executes _method_name,
+      # Auditing method call.  Resolves dependencies, executes method_name,
       # and sends the audited result to the on_complete_block (if set).
       #
-      # Audits are initialized in the follwing manner:
-      # no inputs:: Creates a new, empty Audit.  The first value of the audit
-      #             will be the result of call.
-      # one input:: Forks the input if it is an audit, otherwise initializes
-      #             a new audit using the input.
-      # multiple inputs:: Merges the inputs into a new Audit.
-      #
+      # Returns the audited result.
       def _execute(*inputs)
         resolve_dependencies
         
-        audit = case inputs.length
-        when 0 then Audit.new
-        when 1 
-          audit = inputs.first
-          if audit.kind_of?(Audit) 
-            inputs = [audit._current]
-            audit._fork
+        previous = []
+        inputs.collect! do |input| 
+          if input.kind_of?(Audit) 
+            previous << input
+            input.value
           else
-            Audit.new(audit)
-          end 
-        else
-          sources = []
-          inputs.collect! do |input| 
-            if input.kind_of?(Audit) 
-              sources << input._fork
-              input._current
-            else
-              sources << nil
-              input
-            end
+            previous << Audit.new(nil, input)
+            input
           end
-          Audit.new(inputs, sources)
         end
-      
-        audit._record(self, send(_method_name, *inputs))
+         
+        audit = Audit.new(self, send(method_name, *inputs), previous)
         on_complete_block ? on_complete_block.call(audit) : app.aggregator.store(audit)
         
         audit
       end
       
-      # Calls _execute with the inputs and returns the un-audited result.
+      # Calls _execute with the inputs and returns the non-audited result.
       # Execute is not a batched method.
       def execute(*inputs)
-        _execute(*inputs)._current
+        _execute(*inputs).value
       end
       
       # Raises a TerminateError if app.state == State::TERMINATE.
@@ -294,10 +276,6 @@ module Tap
         end
       end
       
-      def inspect
-        "#<#{self.class.to_s}:#{object_id} _method: #{_method_name} batch_length: #{batch.length} app: #{app}>"
-      end
-      
     end
   end
 end

data/lib/tap/support/join.rb

@@ -24,30 +24,34 @@ module Tap
       
       # Causes the join to iterate the results
       # of the source when enquing the targets.
-      config :iterate, false, &c.boolean
+      config :iterate, false, :short => 'i', &c.boolean
+      
+      # Causes joins to splat ('*') the results
+      # of the source when enquing the targets.
+      config :splat, false, :short => 's', &c.boolean
       
       # Causes the targets to be enqued rather
       # than executed immediately.
-      config :stack, false, &c.boolean
+      config :stack, false, :short => 'k', &c.boolean
       
       # Causes joins to only occur between the
       # explicitly named source and targets,
       # and not their batches.
-      config :unbatched, false, &c.boolean
+      config :unbatched, false, :short => 'u', &c.boolean
       
       # An array of workflow flags.  Workflow flags are false unless specified.
       FLAGS = configurations.keys
       
-      # An array of the first character in each WORKFLOW_FLAGS. 
-      SHORT_FLAGS = FLAGS.collect {|flag| flag.to_s[0,1]}
+      # An array of the shorts in each WORKFLOW_FLAGS. 
+      SHORT_FLAGS = configurations.values.collect {|config| config.attributes[:short] }
       
       # Initializes a new join with the specified configuration.
       def initialize(config)
         initialize_config(config)
       end
       
-      # The name of the join, as a symbol.  By default 
-      # name is the basename of the underscored class.
+      # The name of the join, as a symbol.  By default name 
+      # is the basename of the underscored class name.
       def name
         File.basename(self.class.to_s.underscore).to_sym
       end
@@ -85,34 +89,55 @@ module Tap
       #
       #                true                       false
       #   iterate      _results are iterated      _results are enqued directly
+      #   splat        _results are splat enqued  _results are enqued directly
       #   stack        the executable is enqued   the executable is executed
       #   unbatched    only exectuable is enqued  executable.batch is enqued
       #
-      def enq(executable, _results)
-        app = executable.app
-        
-        results = iterate ? _results._iterate : [_results]
-        results.each do |_result|
+      def enq(executable, *_results)
+        unpack(_results) do |_result|
           if stack 
-      
             if unbatched
-              executable.unbatched_enq(_result)
+              executable.unbatched_enq(*_result)
             else
-              executable.enq(_result)
+              executable.enq(*_result)
             end
-      
           else
-      
             if unbatched
-              executable._execute(_result)
+              executable._execute(*_result)
             else
               executable.batch.each do |e|
-                e._execute(_result)
+                e._execute(*_result)
               end
             end
+          end
+        end
+      end
+      
+      # helper method to splat/iterate audited results
+      def unpack(_results) # :nodoc:
+        case
+        when iterate && splat
+          raise "splat and iterate"
+        when iterate
+          _splat(_results).each {|_result| yield(_result) }
+        when splat
+          yield(_splat(_results))
+        else
+          yield(_results)
+        end
+      end
       
+      # helper to splat audits
+      def _splat(_results)  # :nodoc:
+        array = []
+        _results.each do |_result|
+          unless _result.kind_of?(Audit)
+            _result = Audit.new(nil, _result)
           end
+          
+          array.concat(_result.splat)
         end
+        array
       end
     end
     

data/lib/tap/support/joins/sync_merge.rb

@@ -33,7 +33,7 @@ module Tap
 
           sources.each_with_index do |source, index|
             complete(source) do |_result|
-              src = _result._current_source
+              src = _result.key
 
               source_index = indicies[src]
               (combinations[src] ||= []).each do |combination|
@@ -43,11 +43,9 @@ module Tap
 
                 combination[source_index] = _result
                 unless combination.include?(nil)
-                  # merge the source audits
-                  _merge_result = Support::Audit.merge(*combination)
 
-                  yield(_merge_result) if block_given?
-                  enq(target, _merge_result)
+                  yield(*combination) if block_given?
+                  enq(target, *combination)
 
                   # reset the group array
                   combination.collect! {|i| nil }

data/lib/tap/support/parser.rb

@@ -234,7 +234,7 @@ module Tap
         # if the options string contains unknown options.
         #
         #   parse_options("")                   # => {}
-        #   parse_options("is")                 # => {:iterate => true, :stack => true}
+        #   parse_options("ik")                 # => {:iterate => true, :stack => true}
         #
         def parse_options(three)
           options = {}

data/lib/tap/task.rb

@@ -1,11 +1,12 @@
 require 'tap/support/executable'
-require 'tap/support/lazydoc/method'
-require 'tap/support/lazydoc/definition'
 require 'tap/support/intern'
-autoload(:OptionParser, 'optparse')
+autoload(:ConfigParser, 'config_parser')
 
 module Tap
-
+  module Support
+    autoload(:Templater, 'tap/support/templater')
+  end
+  
   # === Task Definition
   #
   # Tasks specify executable code by overridding the process method in
@@ -29,9 +30,8 @@ module Tap
   #   MixedInputs.new.execute(:a, :b)              # => [:a, :b, []]
   #   MixedInputs.new.execute(:a, :b, 1, 2, 3)     # => [:a, :b, [1,2,3]]
   #
-  # Tasks may be create with new, or with intern.  Intern overrides
-  # process with a custom block that gets called with the task instance
-  # and the inputs.
+  # Tasks may be create with new, or with intern.  Intern overrides process
+  # using a block that receives the task instance and the inputs.
   #
   #   no_inputs = Task.intern {|task| [] }
   #   one_input = Task.intern {|task, input| [input] }
@@ -67,8 +67,8 @@ module Tap
   #   t.respond_to?(:three)        # => false
   #
   # Configurations can be validated/transformed using an optional block.  
-  # Tap::Support::Validation pre-packages many common blocks which may
-  # be accessed through the class method 'c':
+  # Many common blocks are pre-packaged and may be accessed through the
+  # class method 'c':
   #
   #   class ValidatingTask < Tap::Task
   #     # string config validated to be a string
@@ -85,40 +85,31 @@ module Tap
   #   t.integer = "1"
   #   t.integer == 1         # => true 
   #
-  #--
-  # === Subclassing
-  # Tasks can be subclassed normally, with one reminder related to batching.
+  # See the {Configurable}[http://tap.rubyforge.org/configurable/]
+  # documentation for more information.
   #
-  # Batched tasks are generated by duplicating an existing instance, hence
-  # all instance variables will point to the same object in the batched
-  # and original task.  At times (as with configurations), this is 
-  # undesirable; the batched task should have it's own copy of an 
-  # instance variable.
+  # === Subclassing
+  # Tasks may be subclassed normally, but be sure to call super as necessary,
+  # in particular when overriding the following methods:
   #
-  # In these cases, the <tt>initialize_copy</tt> should be overridden
-  # and should re-initialize the appropriate variables.  Be sure to call
-  # super to invoke the default <tt>initialize_copy</tt>:
+  #   class Subclass < Tap::Task
+  #     class << self
+  #       def inherited(child)
+  #         super
+  #       end
+  #     end
   #
-  #   class SubclassTask < Tap::Task
-  #     attr_accessor :array
   #     def initialize(*args)
-  #       @array = []
   #       super
   #     end
-  #  
+  #
   #     def initialize_copy(orig)
-  #       @array = orig.array.dup
   #       super
   #     end
   #   end
   #
-  #   t1 = SubclassTask.new
-  #   t2 = t1.initialize_batch_obj
-  #   t1.array == t2.array                         # => true
-  #   t1.array.object_id == t2.array.object_id     # => false
-  #
   class Task
-    include Support::Configurable
+    include Configurable
     include Support::Executable
     
     class << self
@@ -140,15 +131,15 @@ module Tap
       # 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
+        @instance ||= new.extend(Support::Dependency)
       end
       
       def inherited(child) # :nodoc:
         unless child.instance_variable_defined?(:@source_file)
-          caller.first =~ Support::Lazydoc::CALLER_REGEXP
+          caller[0] =~ Lazydoc::CALLER_REGEXP
           child.instance_variable_set(:@source_file, File.expand_path($1)) 
         end
-
+        
         child.instance_variable_set(:@dependencies, dependencies.dup)
         super
       end
@@ -168,87 +159,59 @@ module Tap
       end
       
       # Parses the argv into an instance of self and an array of arguments 
-      # (implicitly to be enqued to the instance).  Yields a help string to
-      # the block when the argv indicates 'help'.
-      def parse(argv=ARGV, app=Tap::App.instance, &block) # :yields: help_str
-        parse!(argv.dup, &block)
+      # (implicitly to be enqued to the instance).
+      def parse(argv=ARGV, app=Tap::App.instance)
+        parse!(argv.dup)
       end
       
-      # Same as parse, but removes switches destructively. 
-      def parse!(argv=ARGV, app=Tap::App.instance) # :yields: help_str
-        opts = OptionParser.new
-
-        # Add configurations
-        argv_config = {}
-        unless configurations.empty?
-          opts.separator ""
-          opts.separator "configurations:"
-        end
-
-        configurations.each do |receiver, key, config|
-          opts.on(*config.to_optparse_argv) do |value|
-            argv_config[key] = value
-          end
-        end
-
-        # Add options on_tail, giving priority to configurations
+      # Same as parse, but removes switches destructively.
+      def parse!(argv=ARGV, app=Tap::App.instance)
+        opts = ConfigParser.new
+        opts.separator "configurations:"
+        opts.add(configurations)
+        
         opts.separator ""
         opts.separator "options:"
-
-        opts.on_tail("-h", "--help", "Print this help") do
+        
+        # Add option to print help
+        opts.on("-h", "--help", "Print this help") do
           prg = case $0
           when /rap$/ then 'rap'
           else 'tap run --'
           end
           
-          opts.banner = "#{help}usage: #{prg} #{to_s.underscore} #{args.subject}"
-          if block_given? 
-            yield(opts.to_s)
-          else
-            puts opts
-            exit
-          end
+          puts "#{help}usage: #{prg} #{to_s.underscore} #{args}"
+          puts          
+          puts opts
+          exit
         end
-
-        # Add option for name
+ 
+        # Add option to specify a config file
         name = default_name
-        opts.on_tail('--name NAME', /^[^-].*/, 'Specify a name') do |value|
+        opts.on('--name NAME', 'Specify a name') do |value|
           name = value
         end
-
+ 
         # Add option to add args
         use_args = []
-        opts.on_tail('--use FILE', /^[^-].*/, 'Loads inputs from file') do |value|
-          obj = YAML.load_file(value)
-          case obj
-          when Hash 
-            obj.values.each do |array|
-              # error if value isn't an array
-              use_args.concat(array)
-            end
-          when Array 
-            use_args.concat(obj)
-          else
-            use_args << obj
-          end
+        opts.on('--use FILE', 'Loads inputs from file') do |path|
+          use(path, use_args)
         end
         
-        # parse the argv
-        opts.parse!(argv)
-        
         # build and reconfigure the instance and any associated
         # batch objects as specified in the file configurations
-        obj = new({}, name, app)
-        path_configs = load_config(app.config_filepath(name))
-        if path_configs.kind_of?(Array)
-          path_configs.each_with_index do |path_config, i|
-            next if i == 0
-            batch_obj = obj.initialize_batch_obj(path_config, "#{name}_#{i}")
-            batch_obj.reconfigure(argv_config)
-          end
-          path_configs = path_configs[0]
+        argv = opts.parse!(argv)
+        configs = load(app.config_filepath(name))
+        configs = [configs] unless configs.kind_of?(Array)
+        
+        obj = new(configs.shift, name, app)
+        configs.each do |config|
+          obj.initialize_batch_obj(config, "#{name}_#{obj.batch.length}")
+        end        
+
+        obj.batch.each do |batch_obj|
+          batch_obj.reconfigure(opts.config)
         end
-        obj.reconfigure(path_configs).reconfigure(argv_config)
         
         [obj, (argv + use_args)]
       end
@@ -256,58 +219,143 @@ module Tap
       # A convenience method to parse the argv and execute the instance
       # with the remaining arguments.  If 'help' is specified in the argv, 
       # execute prints the help and exits.
+      #
+      # Returns the non-audited result.
       def execute(argv=ARGV)
-        instance, args = parse(ARGV) do |help|
-          puts help
-          exit
-        end
-
+        instance, args = parse(ARGV)
         instance.execute(*args)
       end
-      
-      # Returns the class lazydoc, resolving if specified.
-      def lazydoc(resolve=true)
-        lazydoc = super(false)
-        lazydoc[self.to_s]['args'] ||= lazydoc.register_method(:process, Support::Lazydoc::Method)
-        super
-      end
 
       DEFAULT_HELP_TEMPLATE = %Q{<% manifest = task_class.manifest %>
-<%= task_class %><%= manifest.subject.to_s.strip.empty? ? '' : ' -- ' %><%= manifest.subject %>
+<%= task_class %><%= manifest.empty? ? '' : ' -- ' %><%= manifest.to_s %>
 
-<% unless manifest.empty? %>
+<% desc = manifest.kind_of?(Lazydoc::Comment) ? manifest.wrap(77, 2, nil) : [] %>
+<% unless desc.empty? %>
 <%= '-' * 80 %>
 
-<% manifest.wrap(77, 2, nil).each do |line| %>
+<% desc.each do |line| %>
   <%= line %>
 <% end %>
 <%= '-' * 80 %>
 <% end %>
 
 }
+      
       # Returns the class help.
       def help
         Tap::Support::Templater.new(DEFAULT_HELP_TEMPLATE, :task_class => self).build
       end
       
+      # Recursively loads path into a nested configuration file.
+      #--
+      # TODO: move the logic of this to Configurable
+      def load(path, recursive=true)
+        base = Root.trivial?(path) ? {} : (YAML.load_file(path) || {})
+        
+        if recursive
+          # determine the files/dirs to load recursively
+          # and add them to paths by key (ie the base
+          # name of the path, minus any extname)
+          paths = {}
+          files, dirs = Dir.glob("#{path.chomp(File.extname(path))}/*").partition do |sub_path|
+            File.file?(sub_path)
+          end
+
+          # directories are added to paths first so they can be
+          # overridden by the files (appropriate since the file
+          # will recursively load the directory if it exists)
+          dirs.each do |dir|
+            paths[File.basename(dir)] = dir
+          end
+
+          # when adding files, check that no two files map to
+          # the same key (ex a.yml, a.yaml).
+          files.each do |filepath|
+            key = File.basename(filepath).chomp(File.extname(filepath))
+            if existing = paths[key]
+              if File.file?(existing)
+                confict = [File.basename(paths[key]), File.basename(filepath)].sort
+                raise "multiple files load the same key: #{confict.inspect}"
+              end
+            end
+
+            paths[key] = filepath
+          end
+
+          # recursively load each file and reverse merge
+          # the result into the base
+          paths.each_pair do |key, recursive_path|
+            value = nil
+            each_hash_in(base) do |hash|
+              unless hash.has_key?(key)
+                hash[key] = (value ||= load(recursive_path, true))
+              end
+            end
+          end
+        end
+
+        base
+      end
+      
+      # Loads the contents of path onto argv.
+      def use(path, argv=ARGV)
+        obj = Root.trivial?(path) ? [] : (YAML.load_file(path) || [])
+        
+        case obj
+        when Array then argv.concat(obj)
+        else argv << obj
+        end
+        
+        argv
+      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.
+      # 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.
+      # If a non-nil name is specified, depends_on will create a reader of 
+      # the resolved dependency value.
+      #
+      #   class A < Tap::Task
+      #     def process
+      #       "result"
+      #     end
+      #   end
+      #
+      #   class B < Tap::Task
+      #     depends_on :a, A
+      #   end
+      #
+      #   b = B.new
+      #   b.dependencies           # => [A.instance]
+      #   b.a                      # => "result"
+      #
+      #   A.instance.resolved?     # => true
+      # 
+      # Normally class-level dependencies are not added to existing instances
+      # but, as a special case, depends_on updates instance to depend on
+      # dependency_class.instance.
+      #
+      # Returns self.
       def depends_on(name, dependency_class)
         unless dependencies.include?(dependency_class)
           dependencies << dependency_class
         end
         
-        # returns the resolved result of the dependency
-        define_method(name) do
-          instance = dependency_class.instance
-          instance.resolve
-          instance._result._current
+        # update instance with the dependency if necessary
+        if instance_variable_defined?(:@instance)
+          instance.depends_on(dependency_class.instance)
+        end
+        
+        if name
+          # returns the resolved result of the dependency
+          define_method(name) do
+            dependency_class.instance.resolve.value
+          end
+        
+          public(name)
         end
         
-        public(name)
         self
       end
       
@@ -394,45 +442,42 @@ module Tap
           subclass.send(:define_method, :process, &block)
         end
         
-        # 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
-        end
-        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
+          caller[0] =~ Lazydoc::CALLER_REGEXP
+          desc = Lazydoc.register($1, $3.to_i - 1)#, Lazydoc::Definition)
+          #desc.subclass = subclass
           options[:desc] = desc
         end
         
-        configurations.add(name, subclass.configurations.instance_config, options)
+        nest(name, subclass, options) {|overrides| subclass.new(overrides) }
+      end
+      
+      private
+      
+      # helper for load_config.  yields each hash in the collection (ie each
+      # member of an Array, or the collection if it is a hash). returns
+      # the collection.
+      def each_hash_in(collection) # :nodoc:
+        case collection
+        when Hash then yield(collection)
+        when Array
+          collection.each do |hash|
+            yield(hash) if hash.kind_of?(Hash)
+          end
+        end
+
+        collection
       end
     end
     
     instance_variable_set(:@source_file, __FILE__)
     instance_variable_set(:@default_name, 'tap/task')
     instance_variable_set(:@dependencies, [])
+    
     lazy_attr :manifest
-    lazy_attr :args
+    lazy_attr :args, :process
+    lazy_register :process, Lazydoc::Arguments
     
     # The name of self.
     #--
@@ -446,21 +491,21 @@ module Tap
 
       @name = name || self.class.default_name
       @app = app
-      @_method_name = :execute_with_callbacks
+      @method_name = :execute_with_callbacks
       @on_complete_block = nil
       @dependencies = []
       @batch = [self]
       
       case config
-      when Support::InstanceConfiguration
+      when DelegateHash
         # 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)
+        @config = config.update.bind(self)
       else 
         initialize_config(config)
       end
       
+      # setup class dependencies
       self.class.dependencies.each do |dependency_class|
         depends_on(dependency_class.instance)
       end