bahuvrihi-tap 0.11.2 → 0.12.0

data/bin/rap

@@ -73,16 +73,15 @@ begin
 <% entries.each do |name, const| %>
 <%   desc = if const.require_path == nil # should be a declaration %>
 <%     manifest = const.constantize.manifest %>
-<%     next if manifest == nil || manifest.subject.to_s.empty? %>
+<%     next if manifest == nil || manifest.empty? %>
 <%     manifest %>
 <%   else %>
 <%     const.document[const.name]['manifest'] %>
 <%   end %>
-<%   desc = desc.subject.to_s if desc.kind_of?(Tap::Support::Lazydoc::Comment) %>
   <%= name.ljust(width) %><%= desc.empty? ? '' : '  # ' %><%= desc %>
 <% end %>}
 
-    puts Tap::Support::Lazydoc.usage(__FILE__)
+    puts Lazydoc.usage(__FILE__)
     puts
     puts "===  tap tasks ==="
     puts env.summarize(:tasks, rap_template)

data/bin/tap

@@ -59,7 +59,7 @@ end
 begin
   env.activate
   env.execute(ARGV) do
-    puts Tap::Support::Lazydoc.usage(__FILE__)
+    puts Lazydoc.usage(__FILE__)
     puts
     puts "available commands:"
     puts env.summarize(:commands)

data/cmd/console.rb

@@ -7,12 +7,12 @@
 # handle options
 #
 
-OptionParser.new do |opts|
+ConfigParser.new do |opts|
   opts.separator ""
   opts.separator "options:"
 
   opts.on("-h", "--help", "Show this message") do
-    opts.banner = Tap::Support::Lazydoc.usage(__FILE__)
+    puts Lazydoc.usage(__FILE__)
     puts opts
     exit
   end

data/cmd/manifest.rb

@@ -4,13 +4,13 @@
 #
 
 options = {}
-OptionParser.new do |opts|
+ConfigParser.new do |opts|
   
   opts.separator ""
   opts.separator "options:"
 
   opts.on("-h", "--help", "Show this message") do
-    opts.banner = Tap::Support::Lazydoc.usage(__FILE__)
+    puts Lazydoc.usage(__FILE__)
     puts opts
     exit
   end

data/cmd/run.rb

@@ -13,24 +13,22 @@ app = Tap::App.instance
 #
 
 dump = false
-OptionParser.new do |opts|
+ConfigParser.new do |opts|
   opts.separator ""
   opts.separator "configurations:"
   
-  Tap::App.configurations.each do |receiver, key, config|
-    next if receiver == Tap::Root
-    
-    opts.on(*config.to_optparse_argv) do |value|
-      app.send(config.writer, value)
-    end
+  root_keys = Tap::Root.configurations.keys
+  Tap::App.configurations.each_pair do |key, config|
+    next if root_keys.include?(key)
+    opts.define(key, config.default, config.attributes)
   end
  
   opts.separator ""
   opts.separator "options:"
-
+ 
   opts.on("-h", "--help", "Show this message") do
-    opts.banner = Tap::Support::Lazydoc.usage(__FILE__)
     Tap::App.lazydoc.resolve
+    puts Lazydoc.usage(__FILE__)
     puts opts
     exit
   end

data/cmd/server.rb

@@ -11,22 +11,22 @@ env = Tap::Env.instance
 # handle options
 #
 options = {:Port => 8080}
-OptionParser.new do |opts|
+ConfigParser.new do |opts|
   
   opts.separator ""
   opts.separator "options:"
 
   opts.on("-h", "--help", "Show this message") do
-    opts.banner = Tap::Support::TDoc.usage(__FILE__)
+    puts Lazydoc.usage(__FILE__)
     puts opts
     exit
   end
   
-  opts.on("-p", "--port PORT", Integer, "Specifies the port (default #{options[:Port]})") do |value|
-    options[:Port] = value
+  opts.on("-p", "--port PORT", "Specifies the port (default 8080)") do |value|
+    options[:Port] = value.to_i
   end
   
-  opts.on("-d", "--development", Integer, "Specifies development mode") do
+  opts.on("-d", "--development", "Specifies development mode") do
     env.config[:development] = true
   end
   

data/doc/Class Reference

@@ -18,16 +18,14 @@ Executable extends objects allowing them to be used in workflows, enqued, and ru
 
 Tasks are constructed such that <tt>process</tt> is the executable method (actually execute_with_callbacks is used to wrap process with before/after execute callbacks, but effectively this is the case).  Hence <tt>process</tt> is the standard method overridden in Task subclasses.
 
-==== Tap::Support::Configurable
+==== {Configurable}[http://tap.rubyforge.org/configurable/]
 
 http://tap.rubyforge.org/images/Configurable.png
 
-Configurable allows declaration of class configurations.  Configurable classes have a <tt>configurations</tt> method accessing a {ClassConfiguration}[link:classes/Tap/Support/ClassConfiguration.html] which holds all declared configs, their default values, and metadata for transforming configurations into command line options (for example).  
-
-Instances of a Configurable class have a <tt>config</tt> method accessing a {InstanceConfiguration}[link:classes/Tap/Support/InstanceConfiguration.html] object.  The instance configuration acts like a forwarding hash; read and write operations for declared configs get forwarded to class methods while undeclared configs are stored directly.  The writer for a config may be defined through a block provided during config declaration.  For instance:
-
+Tap uses the {Configurable}[http://tap.rubyforge.org/configurable/] module to declare class configurations and make them available in for use in contexts like the command line.  Configurations essentially consist of a reader, writer, and default value, but they may additionally be accessed through a hash-like config object.  For instance:
+  
   class ConfigClass
-    include Tap::Support::Configurable
+    include Configurable
 
     config :key, 'value' do |input|
       input.upcase
@@ -52,7 +50,7 @@ Is basically the same as:
     end
   end
 
-As you can see here:
+And as you can see here:
 
   c = ConfigClass.new
   c.key                       # => 'VALUE'
@@ -65,12 +63,12 @@ As you can see here:
 
 This setup is both fast and convenient.  
 
-==== Tap::Support::Validation
+==== {Configurable::Validation}[http://tap.rubyforge.org/configurable/classes/Configurable/Validation.html]
 
-When configurations are set from the command line, the writer method will inevitably receive a string, whereas configurations set within code can receive any type of object.  The {Validation}[link:classes/Tap/Support/Validation.html] module provides standard blocks for validating and transforming inputs, accessible through the <tt>c</tt> method (ex: <tt>c.integer</tt> or <tt>c.regexp</tt>).  These blocks (generally) load string inputs as YAML and validate that the result is the correct class; non-string inputs are simply validated.
+When configurations are set from the command line, the writer method inevitably receives a string, even though a non-string input may be desired.  The {Validation}[http://tap.rubyforge.org/configurable/classes/Configurable/Validation.html] module provides standard blocks for validating and transforming inputs, accessible through the <tt>c</tt> method (ex: <tt>c.integer</tt> or <tt>c.regexp</tt>).  These blocks (generally) load string inputs as YAML and validate that the result is the correct class; non-string inputs are simply validated.
 
   class ValidatingClass
-    include Tap::Support::Configurable
+    include Configurable
 
     config :int, 1, &c.integer                 # assures the input is an integer
     config :int_or_nil, 1, &c.integer_or_nil   # integer or nil only
@@ -89,9 +87,9 @@ When configurations are set from the command line, the writer method will inevit
 
 Validation blocks sometimes imply metadata.  For instance <tt>c.flag</tt> makes a config into a flag on the command line.
 
-==== Tap::Support::Lazydoc
+==== {Lazydoc}[http://tap.rubyforge.org/lazydoc]
 
-Ah lazydoc.  Lazydoc fits into the space between live code and code documentation.  Lazydoc can scan a file (code or not) and pull documentation into the object space where it can be utilized.  Lazydoc uses a key-value syntax like this:
+Ah lazydoc.  {Lazydoc}[http://tap.rubyforge.org/lazydoc] fits into the space between live code and code documentation.  Lazydoc can scan a file (code or not) and pull documentation into the object space where it can be utilized.  Lazydoc uses a key-value syntax like this:
 
   # ::key value
 
@@ -112,10 +110,10 @@ Lazydoc parses a constant name, the key, the value, and any comment following th
 
   require 'tap'
 
-  lazydoc = Tap::Support::Lazydoc[__FILE__]
+  lazydoc = Lazydoc[__FILE__]
   lazydoc.resolve
 
-  lazydoc['Name::Space']['key'].to_s           # => "This documentation gets parsed."
+  lazydoc['Name::Space']['key'].comment        # => "This documentation gets parsed."
   lazydoc['Name::Space']['another'].value      # => "another value"
 
 Furthermore, Lazydoc can register specific lines for documentation.  These lines are parsed to echo what happens in RDoc.
@@ -128,7 +126,7 @@ Furthermore, Lazydoc can register specific lines for documentation.  These lines
 
   require 'tap'
 
-  lazydoc = Tap::Support::Lazydoc[__FILE__]
+  lazydoc = Lazydoc[__FILE__]
   code_comment = lazydoc.register(2)
   lazydoc.resolve
   
@@ -146,7 +144,7 @@ When no constant name is specified for a Lazydoc key, Env uses a constant based
   # If more than one task is defined in this file, or if Sample::Task
   # is not defined by loading this file, Tap will run into trouble.
 
-However, the best practice is to include the namespace explicitly.
+However, the best practice is to include the namespace explicitly.  See the {Lazydoc}[http://tap.rubyforge.org/lazydoc] documentation for more information.
 
 === Tap::Task
 
@@ -205,7 +203,7 @@ Tracking the evolution of a result through a workflow can get complex; Tap audit
   t3.name = 'trois'
   
   app._results(t2).collect do |_result|
-    _result._to_s
+    _result.dump
   end.join("---\n")
   # => 
   # o-[] "input"
@@ -222,7 +220,7 @@ Tracking the evolution of a result through a workflow can get complex; Tap audit
 
 http://tap.rubyforge.org/images/Root.png
 
-A Root represents the base of a directory structure. Roots allow you to alias directories and ease working with filepaths, basically allowing you to develop code for a conceptual directory structure that can be defined later.
+A Root represents the base of a directory structure. Roots allow you to alias relative paths, basically allowing you to develop code for a conceptual directory structure that can be defined later.
 
   root = Tap::Root.new '/path/to/root'
   root.root                                      # => '/path/to/root'
@@ -248,8 +246,7 @@ Tap tracks inputs as they are modified by various tasks, again through Executabl
 Auditing is largely invisible except in <tt>on_complete</tt> blocks.  <tt>on_complete</tt> blocks receive the audited results so that this information can be used, as needed, to make decisions.  
 
     Task.new.on_complete do |_result|            # _result is an Audit instance
-      _result._current                           # the current value
-      _result._original                          # the original value
+      _result.value                              # the current value
     end
 
 To help indicate when a result is actually a result and when it is an audit, Tap uses a convention whereby a leading underscore signals auditing is involved.

data/doc/Tutorial

@@ -98,8 +98,6 @@ Here is a corresponding class:
 
 Simple enough; the name corresponds to the class, configurations (and dependencies, although they aren't show) are written out individually, and the block corresponds to process.  There are a few differences, especially relating to process, but for the moment lets gloss over them and see how Goodnight works.
 
-  Goodnight.configurations.to_hash         # => {:message => 'goodnight'}
-  
   goodnight = Goodnight.new
   goodnight.message                        # => 'goodnight'
   goodnight.process('moon')                # => 'goodnight moon'
@@ -108,7 +106,7 @@ Simple enough; the name corresponds to the class, configurations (and dependenci
   hello.message                            # => 'hello'
   hello.process('world')                   # => 'hello world'
 
-Totally straightforward.  Goodnight stores the default configurations, each instance has accessors to the configurations, and the defaults may be overridden during initialization, or later.  Class definitions allow validation/transformation blocks to be specified for configurations.  These blocks process inputs (ex the string inputs from the command line), quite literally defining the writer for a configuration accessor.  A set of standard blocks are available through +c+, an alias for the Tap::Support::Validation module.
+Totally straightforward.  Goodnight stores the default configurations, each instance has accessors to the configurations, and the defaults may be overridden during initialization, or later.  Class definitions allow validation/transformation blocks to be specified for configurations.  These blocks process inputs (ex the string inputs from the command line), quite literally defining the writer for a configuration accessor.  A set of standard blocks are available through +c+, an alias for the {Configurable::Validation}[http://tap.rubyforge.org/configurable/classes/Configurable/Validation.html] module.
 
   [lib/goodnight.rb]
   
@@ -166,9 +164,9 @@ Now from the command line:
           --name NAME                  Specify a name
           --use FILE                   Loads inputs from file
 
-Take a quick look at the documentation.  Class definitions can also map documentation and, in some cases, metadata to the command line; the configurations now have comments and reverse is a switch!  Rich mapping allows tasks to act as an script interface, not unlike {OptionParser}[http://www.ruby-doc.org/stdlib/libdoc/optparse/rdoc/classes/OptionParser.html] (surprise, tap uses OptionParser).
+Take a quick look at the documentation.  Class definitions map documentation and, in some cases, metadata to the command line; the configurations now have comments and reverse is a switch!  Rich mapping allows tasks to act as an script interface, not unlike {OptionParser}[http://www.ruby-doc.org/stdlib/libdoc/optparse/rdoc/classes/OptionParser.html] (check out the {Configurable}[http://tap.rubyforge.org/configurable/] gem and specifically {ConfigParser}[http://tap.rubyforge.org/configurable/classes/ConfigParser.html] for more details).
 
-For example this is a stand-alone goodnight script:
+This is a stand-alone goodnight script:
 
   [goodnight]
   
@@ -208,7 +206,7 @@ Tap comes with two executables, rap and tap.  The tap executable is more verbose
   % cd sample
   % tap generate task goodnight
 
-Take a look at the task files an you find something like this:
+Take a look at the task files and you find something like this:
 
   [lib/goodnight.rb]
   
@@ -247,7 +245,7 @@ Take a look at the task files an you find something like this:
       app.run
 
       assert_equal ["goodnight moon"], app.results(task)
-      assert_audit_equal ExpAudit[[nil, "moon"], [task, "goodnight moon"]], app._results(task)[0]
+      assert_audit_equal [[nil, "moon"], [task, "goodnight moon"]], app._results(task)[0]
     end
   end
 

data/lib/tap.rb

@@ -2,6 +2,8 @@ autoload(:YAML, 'yaml')                   # expensive to load
 
 $:.unshift File.expand_path(File.dirname(__FILE__))
 
+require 'rubygems'
+require 'configurable'
 require 'tap/constants'
 
 # require in order...

data/lib/tap/app.rb

@@ -106,9 +106,8 @@ module Tap
   #   add_five = Tap::Task.intern({}, 'add_five') {|task, input| input += 5 }
   #
   #   add_one.on_complete do |_result|
-  #     # _result is the audit; use the _current method
-  #     # to get the current value in the audit trail
-  #     current_value = _result._current
+  #     # _result is the audit
+  #     current_value = _result.value
   #
   #     if current_value < 3 
   #       add_one.enq(_result)
@@ -128,33 +127,23 @@ module Tap
   # through a different series of tasks. With auditing you can see how each 
   # input came to the final value of 8:
   #
-  #   # app.results returns the actual result values
-  #   # app._results returns the audits for these values
-  #   app._results(add_five).each do |_result|
-  #     puts "How #{_result._original} became #{_result._current}:"
-  #     puts _result._to_s
-  #     puts
-  #   end
-  #
-  # Prints:
-  #
-  #   How 2 became 8:
-  #   o-[] 2
-  #   o-[add_one] 3
-  #   o-[add_five] 8
-  #
-  #   How 1 became 8:
-  #   o-[] 1
-  #   o-[add_one] 2
-  #   o-[add_one] 3
-  #   o-[add_five] 8
-  #
-  #   How 0 became 8:
-  #   o-[] 0
-  #   o-[add_one] 1
-  #   o-[add_one] 2
-  #   o-[add_one] 3
-  #   o-[add_five] 8
+  #   "\n" + Tap::Support::Audit.dump(app._results(add_five), "")
+  #    # => %Q{
+  #    # o-[] 2
+  #    # o-[add_one] 3
+  #    # o-[add_five] 8
+  #    # 
+  #    # o-[] 1
+  #    # o-[add_one] 2
+  #    # o-[add_one] 3
+  #    # o-[add_five] 8
+  #    # 
+  #    # o-[] 0
+  #    # o-[add_one] 1
+  #    # o-[add_one] 2
+  #    # o-[add_one] 3
+  #    # o-[add_five] 8
+  #    # }
   #
   # See Tap::Support::Audit for more details.
   class App < Root
@@ -378,9 +367,10 @@ module Tap
     #   app.results(t1, t0)           # => ["1.1", "0.0"]
     #
     def results(*tasks)
-      _results(tasks).collect {|_result| _result._current}
+      _results(tasks).collect {|_result| _result.value }
     end
     
+    # Returns a string like: "#<Tap::App:#{object_id} root: #{root} >"
     def inspect
       "#<#{self.class.to_s}:#{object_id} root: #{root} >"
     end

data/lib/tap/constants.rb

@@ -1,7 +1,7 @@
 module Tap
   MAJOR = 0
-  MINOR = 11
-  TINY = 2
+  MINOR = 12
+  TINY = 0
   
   VERSION="#{MAJOR}.#{MINOR}.#{TINY}" 
   WEBSITE="http://tap.rubyforge.org"

data/lib/tap/declarations.rb

@@ -1,5 +1,6 @@
 require File.dirname(__FILE__) + "/../tap"
-autoload(:OpenStruct, 'ostruct')
+require "tap/declarations/description"
+require "tap/declarations/declaration_task"
 
 module Tap
   #--
@@ -8,38 +9,9 @@ module Tap
   # the top level (for main/Object) while extend should be used
   # in all other cases.
   module Declarations
-    Lazydoc = Tap::Support::Lazydoc
     include Tap::Support::ShellUtils
     
-    module Lazydoc
-      class Declaration < Comment
-        attr_accessor :desc
-        
-        def resolve(lines)
-          super
-          
-          @subject = case
-          when content.empty? || content[0][0].to_s !~ /^::desc(.*)/
-            desc.to_s
-          else
-            content[0].shift
-            $1.strip
-          end
-          
-          self
-        end
-      end
-    end
-    
-    module Rakish
-      def new(*args)
-        @instance ||= super
-        @instance.app.dependencies.register(@instance)
-        @instance
-      end
-    end
-    
-    def self.extended(base)
+    def self.extended(base) # :nodoc:
       declaration_base = base.to_s
       case declaration_base
       when "Object", "Tap", "main"
@@ -50,58 +22,51 @@ module Tap
       base.instance_variable_set(:@current_desc, nil)
     end
     
+    # The Tap::Env for Dir.pwd
     def self.env
       @env ||= Tap::Env.instance_for(Dir.pwd)
     end
     
+    # The environment in which declared task classes are registered.
+    # By default Declarations.env
     def declaration_env
       @declaration_env ||= Declarations.env
     end
     
     attr_writer :declaration_base
     
+    # The base constant for all task declarations, prepended to the task name.
     def declaration_base
       @declaration_base ||= ''
     end
     
     attr_writer :current_desc
     
+    # Tracks the current description, which will be used to
+    # document the next task declaration.
     def current_desc
       @current_desc ||= nil
     end
     
+    # Declares a task with a rake-like syntax
     def task(*args, &block)
-      const_name, configs, dependencies, arg_names = resolve_args(args)
-      task_class = declare(const_name, configs, dependencies) do |*inputs|
-        # collect inputs to make a rakish-args object
-        args = {}
-        arg_names.each do |arg_name|
-          break if inputs.empty?
-          args[arg_name] = inputs.shift
-        end
-        args = OpenStruct.new(args)
-        
-        # execute each block assciated with this task
-        self.class::BLOCKS.each do |task_block|
-          case task_block.arity
-          when 0 then task_block.call()
-          when 1 then task_block.call(self)
-          else task_block.call(self, args)
-          end
-        end
-        
-        nil
-      end
-      register_doc(task_class, arg_names)
+      task_name, configs, needs, arg_names = resolve_args(args)
+      task_class = declare(task_name, configs, needs)
+      
+      # set the arg_names for the subclass
+      task_class.arg_names = arg_names
+      
+      # register the current_desc
+      register_doc(task_class)
       
       # add the block to the task
-      unless task_class.const_defined?(:BLOCKS)
-        task_class.const_set(:BLOCKS, [])
-      end
-      task_class::BLOCKS << block unless block == nil
+      task_class.blocks << block if block
       task_class.instance
     end
     
+    # Appends name to the declaration base for the duration of the block.
+    # This has the effect of nesting any task declarations within the
+    # Name module or class.
     def namespace(name, &block)
       current_base = declaration_base
       @declaration_base = File.join(current_base, name.to_s.underscore)
@@ -109,43 +74,60 @@ module Tap
       @declaration_base = current_base
     end
     
+    # Sets the current description for use by the next task declaration.
     def desc(str)
       self.current_desc = str
     end
     
     protected
     
-    # Resolve the arguments for a task/rule.  Returns an array of
+    # A helper to resolve the arguments for a task; returns the array
     # [task_name, configs, needs, arg_names].
     #
     # Adapted from Rake 0.8.3
     # Changes:
     # - no :needs support for the trailing Hash (which is now config)
-    def resolve_args(args)
+    def resolve_args(args) # :nodoc:
       task_name = args.shift
       arg_names = args
       configs = {}
       needs = []
       
+      # resolve hash task_names, for the syntax:
+      #   task :name => [dependencies]
       if task_name.is_a?(Hash)
         hash = task_name
-        task_name = hash.keys[0]
-        needs = hash[task_name]
+        case hash.length
+        when 0 
+          task_name = nil
+        when 1 
+          task_name = hash.keys[0]
+          needs = hash[task_name]
+        else
+          raise ArgumentError, "multiple task names specified: #{hash.keys.inspect}"
+        end
+      end
+      
+      # ensure a task name is specified
+      if task_name == nil
+        raise ArgumentError, "no task name specified" if args.empty?
       end
       
+      # pop off configurations, if present, using the syntax:
+      #   task :name, :one, :two, {configs...}
       if arg_names.last.is_a?(Hash)
         configs = arg_names.pop
       end
       
       needs = needs.respond_to?(:to_ary) ? needs.to_ary : [needs]
       needs = needs.compact.collect do |need|
+        
         unless need.kind_of?(Class)
+          # lookup or declare non-class dependencies
           name = normalize_name(need).camelize
-          need = Support::Constant.constantize(name) do |base, constants|
-            declare(name)
-          end
+          need = Support::Constant.constantize(name) {|base, constants| declare(name) }
         end
-  
+        
         unless need.ancestors.include?(Tap::Task)
           raise ArgumentError, "not a task: #{need}"
         end
@@ -156,45 +138,57 @@ module Tap
       [normalize_name(task_name), configs, needs, arg_names]
     end
     
-    def normalize_name(name)
-      name.to_s.underscore.tr(":", "/")
+    # helper to translate rake-style names to tap-style names, ie
+    #
+    #   normalize_name('nested:name')    # => "nested/name"
+    #   normalize_name(:symbol)          # => "symbol"
+    #
+    def normalize_name(name) # :nodoc:
+      name.to_s.tr(":", "/")
     end
     
-    def declare(name, configs={}, dependencies=[], &block)
-      const_name = File.join(declaration_base, name).camelize
+    # Looks up or creates the DeclarationTask subclass specified by name
+    # (nested within declaration_base), and adds the configs and dependencies.
+    # Declare also registers the subclass in the declaration_env tasks
+    # manifest.
+    # 
+    # Configurations are always validated using the yaml transformation block
+    # (see {Configurable::Validation.yaml}[http://tap.rubyforge.org/configurable/classes/Configurable/Validation.html]).
+    #
+    def declare(name, configs={}, dependencies=[])
+      # assemble the constant name
+      const_name = File.join(declaration_base, name.to_s).camelize
       
-      # generate the subclass
+      # lookup or generate the subclass
       subclass = Support::Constant.constantize(const_name) do |base, constants|
         constants.each do |const|
-          # nesting Tasks into Tasks is required for
-          # namespaces with the same name as a task
-          base = base.const_set(const, Class.new(Tap::Task))
+          # nesting Task classes into other Task classes
+          # is required for namespaces with the same name
+          # as a task
+          base = base.const_set(const, Class.new(DeclarationTask))
         end
         base
       end
-
-      subclass.extend Rakish
       
+      # check a correct class was found
+      unless subclass.ancestors.include?(DeclarationTask)
+        raise "not a DeclarationTask: #{subclass}"
+      end
+      
+      # append configuration (note that specifying a desc 
+      # prevents lazydoc registration of these lines)
+      convert_to_yaml = Configurable::Validation.yaml
       configs.each_pair do |key, value|
-        subclass.send(:config, key, value)
+        subclass.send(:config, key, value, :desc => "", &convert_to_yaml)
       end
       
+      # add dependencies
       dependencies.each do |dependency|
         dependency_name = File.basename(dependency.default_name)
         subclass.send(:depends_on, dependency_name, dependency)
       end
       
-      if block_given?
-        subclass.send(:undef_method, :process) if subclass.method_defined?(:process)
-        subclass.send(:define_method, :process, &block)
-      end
-      
-      # update any dependencies in instance
-      subclass.dependencies.each do |dependency|
-        subclass.instance.depends_on(dependency.instance)
-      end
-      
-      # register the subclass in the manifest
+      # register the subclass in the manifest, if necessary
       manifest = declaration_env.tasks
       const_name = subclass.to_s
       unless manifest.entries.any? {|const| const.name == const_name }
@@ -204,23 +198,17 @@ module Tap
       subclass
     end
     
-    def register_doc(task_class, arg_names)
-      
+    # a helper to register the current_desc as the task_class.manifest
+    def register_doc(task_class) # :nodoc:
       # register documentation
       caller[1] =~ Lazydoc::CALLER_REGEXP
       task_class.source_file = File.expand_path($1)
-      manifest = task_class.lazydoc(false).register($3.to_i - 1, Lazydoc::Declaration)
+      
+      manifest = task_class.lazydoc.register($3.to_i - 1, Description)
       manifest.desc = current_desc
       task_class.manifest = manifest
       
       self.current_desc = nil
-      
-      if arg_names
-        comment = Lazydoc::Comment.new
-        comment.subject = arg_names.collect {|name| name.to_s.upcase }.join(' ')
-        task_class.args = comment
-      end
-
       task_class
     end
   end