bahuvrihi-tap 0.10.6 → 0.10.7

data/bin/rap

@@ -1,7 +1,8 @@
 #!/usr/bin/env ruby
 # usage: rap taskname {options} [args]
 
-require "#{File.dirname(__FILE__)}/../lib/tap.rb"
+$:.unshift "#{File.dirname(__FILE__)}/../lib"
+require 'tap/declarations'
 
 # setup the environment
 begin
@@ -11,9 +12,9 @@ begin
   env = Tap::Exe.instantiate
   
   # add the DEFAULT_TASK_FILE if it exists
-  task_file = File.expand_path('tapfile.rb')
+  task_file = File.expand_path('Tapfile')
   if File.exists?(task_file)
-    env.requires.unshift(task_file)
+    env.loads.unshift(task_file)
     env.manifest(:tasks).search_paths << [Dir.pwd, task_file]
   end
   
@@ -68,7 +69,11 @@ begin
     puts Tap::Support::Lazydoc.usage(__FILE__)
     puts
     puts "===  tap tasks ==="
-    puts env.summarize(:tasks) {|const| const.document[const.name]['manifest'] }
+    str = env.summarize(:tasks) do |const| 
+      const.document.resolve
+      const.document[const.name]['manifest'].subject
+    end
+    puts str
     puts
     puts "=== rake tasks ==="
     Tap::Tasks::Rake.new.enq('-T')
@@ -79,7 +84,10 @@ begin
     puts "version #{Tap::VERSION} -- #{Tap::WEBSITE}"
     exit
   else
-    queues = env.build(ARGV) {|args| Tap::Tasks::Rake }
+    queues = env.build(ARGV) do |args|
+      warn "warning: implict rake for [#{args.join(' ')}]"
+      Tap::Tasks::Rake
+    end
     ARGV.clear
 
     if queues.empty?

data/lib/tap.rb

@@ -14,10 +14,6 @@ require 'tap/constants'
 require 'tap/exe'
 require 'tap/task'
 require 'tap/file_task'
-require 'tap/workflow'
-
-require 'tap/support/declarations'
-Tap.extend Tap::Support::Declarations
 
 # Apply platform-specific patches
 # case RUBY_PLATFORM

data/lib/tap/app.rb

@@ -1,5 +1,6 @@
 require 'logger'
 require 'tap/support/aggregator'
+require 'tap/support/dependencies'
 require 'tap/support/executable_queue'
 
 module Tap
@@ -77,8 +78,8 @@ module Tap
   #
   #   t1 = Task.new  {|task, input| input += 1 }
   #   t2 = Task.new  {|task, input| input += 10 }
-  #   Task.batch(t1, t2)             # => [t1, t2]
   #
+  #   t1.batch_with(t2)
   #   t1.enq 0
   #
   #   app.run
@@ -191,6 +192,8 @@ module Tap
     # methods that have no <tt>on_complete</tt> block
     attr_reader :aggregator
     
+    attr_reader :dependencies
+    
     config :debug, false, &c.flag                 # Flag debugging
     config :force, false, &c.flag                 # Force execution at checkpoints
     config :quiet, false, &c.flag                 # Suppress logging
@@ -222,6 +225,7 @@ module Tap
       @state = State::READY
       @queue = Support::ExecutableQueue.new
       @aggregator = Support::Aggregator.new
+      @dependencies = Support::Dependencies.new
       
       initialize_config(config)
       self.logger = logger
@@ -270,9 +274,7 @@ module Tap
     # aggregator unless an on_complete block is set.  Returns the audited 
     # result.
     def execute(m, inputs)
-      _result = m._execute(*inputs)
-      aggregator.store(_result) unless m.on_complete_block
-      _result
+      m._execute(*inputs)
     end
 
     # Sets state = State::READY unless the app is running.  Returns self.
@@ -371,140 +373,6 @@ module Tap
       m = object._method(method_name)
       enq(m, *inputs)
     end
-    
-    # Sets a sequence workflow pattern for the tasks; each task will enque 
-    # the next task with it's results.
-    #
-    # Notes:
-    # - Batched tasks will have the pattern set for each task in the batch 
-    # - The current audited results are yielded to the block, if given, 
-    #   before the next task is enqued.
-    # - Executables may provided as well as tasks.
-    def sequence(tasks) # :yields: _result
-      current_task = tasks.shift
-      tasks.each do |next_task|
-        # simply pass results from one task to the next.  
-        current_task.on_complete do |_result| 
-          yield(_result) if block_given?
-          enq(next_task, _result)
-        end
-        current_task = next_task
-      end
-    end
-
-    # Sets a fork workflow pattern for the source task; each target
-    # will enque the results of source.
-    #
-    # Notes:
-    # - Batched tasks will have the pattern set for each task in the batch 
-    # - The current audited results are yielded to the block, if given, 
-    #   before the next task is enqued.
-    # - Executables may provided as well as tasks.
-    def fork(source, targets) # :yields: _result
-      source.on_complete do |_result|
-        targets.each do |target| 
-          yield(_result) if block_given?
-          enq(target, _result)
-        end
-      end
-    end
-    
-    # Sets a simple merge workflow pattern for the source tasks. Each source
-    # enques target with it's result; no synchronization occurs, nor are 
-    # results grouped before being sent to the target.
-    #
-    # Notes:
-    # - Batched tasks will have the pattern set for each task in the batch 
-    # - The current audited results are yielded to the block, if given, 
-    #   before the next task is enqued.
-    # - Executables may provided as well as tasks.
-    def merge(target, sources) # :yields: _result
-      sources.each do |source|
-        # merging can use the existing audit trails... each distinct 
-        # input is getting sent to one place (the target)
-        source.on_complete do |_result| 
-          yield(_result) if block_given?
-          enq(target, _result)
-        end
-      end
-    end
-    
-    # Sets a synchronized merge workflow for the source tasks.  Results from
-    # each source task are collected and enqued as a single group to the target. 
-    # The target is not enqued until all sources have completed.  Raises an
-    # error if a source returns twice before the target is enqued.
-    #
-    # Notes:
-    # - Batched tasks will have the pattern set for each task in the batch 
-    # - The current audited results are yielded to the block, if given, 
-    #   before the next task is enqued.
-    # - Executables may provided as well as tasks.
-    #
-    #-- TODO: add notes on testing and the way results are received
-    # (ie as a single object)
-    def sync_merge(target, sources) # :yields: _result
-      group = Array.new(sources.length, nil)
-      sources.each_with_index do |source, index|
-        batch_map = Hash.new(0)
-        batch_length = if source.kind_of?(Support::Batchable)
-          source.batch.each_with_index {|obj, i| batch_map[obj] = i }
-          source.batch.length
-        else
-          1
-        end
-        
-        group[index] = Array.new(batch_length, nil)
-        
-        source.on_complete do |_result|
-          batch_index = batch_map[_result._current_source]
-
-          if group[index][batch_index] != nil
-            raise "sync_merge collision... already got a result for #{_result._current_source}"
-          end
-
-          group[index][batch_index] = _result
-          
-          unless group.flatten.include?(nil)
-            Support::Combinator.new(*group).each do |*combination|
-              # merge the source audits
-              _group_result = Support::Audit.merge(*combination)
-            
-              yield(_group_result) if block_given?
-              target.enq(_group_result)
-            end
-            
-            # reset the group array
-            group.collect! {|i| nil }
-          end 
-        end
-      end
-    end
-    
-    # Sets a choice workflow pattern for the source task.  When the
-    # source task completes, switch yields the audited result to the 
-    # block which then returns 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.
-    #
-    # Notes:
-    # - Batched tasks will have the pattern set for each task in the batch 
-    # - The current audited results are yielded to the block, if given, 
-    #   before the next task is enqued.
-    # - Executables may provided as well as tasks.
-    def switch(source, targets) # :yields: _result
-      source.on_complete do |_result| 
-        if index = yield(_result)        
-          unless target = targets[index] 
-            raise "no switch target for index: #{index}"
-          end
-          
-          enq(target, _result)
-        else
-          aggregator.store(_result)
-        end
-      end
-    end
         
     # Returns all aggregated, audited results for the specified tasks.  
     # Results are joined into a single array.  Arrays of tasks are 
@@ -531,6 +399,10 @@ module Tap
       _results(tasks).collect {|_result| _result._current}
     end
     
+    def inspect
+      "#<#{self.class.to_s}:#{object_id} root: #{root} >"
+    end
+    
     protected
     
     # A hook for handling unknown configurations in subclasses, called from

data/lib/tap/constants.rb

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

data/lib/tap/declarations.rb

@@ -0,0 +1,201 @@
+require "#{File.dirname(__FILE__)}/../tap"
+autoload(:OpenStruct, 'ostruct')
+
+module Tap
+  module Declarations
+    Lazydoc = Tap::Support::Lazydoc
+    
+    module Lazydoc
+      class Declaration < Comment
+        def resolve(lines)
+          super
+          
+          @subject = case
+          when content.empty? || content[0][0].to_s !~ /^::desc(.*)/ then ""
+          else
+            content[0].shift
+            $1.strip
+          end
+          
+          self
+        end
+      end
+    end
+    
+    def self.set_declaration_base(base)
+      # TODO -- warn if base is Object -- conflict with Rake
+      declaration_base = base.to_s
+      declaration_base = "" if ["Object", "Tap"].include?(declaration_base)
+
+      base.instance_variable_set(:@tap_declaration_base, declaration_base.underscore)
+    end
+
+    def self.included(base)
+      set_declaration_base(base)
+    end
+
+    def self.extended(base)
+      set_declaration_base(base)
+    end
+    
+    def tasc(*args, &block)
+      # in this scheme, arg_names will be empty
+      name, configs, dependencies, arg_names = resolve_args(args)
+      declare(Tap::Task, name, configs, dependencies, arg_names, &block)
+    end
+    
+    def task(*args, &block)
+      name, configs, dependencies, arg_names = resolve_args(args)
+      
+      task_class = declare(Tap::Task, name, configs, dependencies, arg_names) do |*inputs|
+        args = {}
+        arg_names.each do |arg_name|
+          break if inputs.empty?
+          args[arg_name] = inputs.shift
+        end
+        
+        args = OpenStruct.new(args)
+        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
+      end
+      
+      unless task_class.const_defined?(:BLOCKS)
+        task_class.const_set(:BLOCKS, [])
+      end
+      task_class::BLOCKS << block unless block == nil
+      
+      task_class.instance
+    end
+    
+    protected
+
+    def config(key, value=nil, options={}, &block)
+      if options[:desc] == nil
+        caller[0] =~ Lazydoc::CALLER_REGEXP
+        options[:desc] = Lazydoc.register($1, $3.to_i - 1)
+      end 
+
+      [:config, key, value, options, block]
+    end
+
+    def config_attr(key, value=nil, options={}, &block)
+      if options[:desc] == nil
+        caller[0] =~ Lazydoc::CALLER_REGEXP
+        options[:desc] = Lazydoc.register($1, $3.to_i - 1)
+      end
+
+      [:config_attr, key, value, options, block]
+    end
+
+    def c
+      Tap::Support::Validation
+    end
+
+    private
+    
+    # Resolve the arguments for a task/rule.  Returns a triplet of
+    # [task_name, configs, prerequisites, arg_name_list].
+    #
+    # From Rake 0.8.3
+    # Changes:
+    # - no :needs support for the trailing Hash (which is now config)
+    def resolve_args(args)
+      task_name = args.shift
+      arg_names = args
+      configs = {}
+      needs = []
+      
+      if task_name.is_a?(Hash)
+        hash = task_name
+        task_name = hash.keys[0]
+        needs = hash[task_name]
+      end
+      
+      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|
+        dependency, argv = case need
+        when Array then need
+        else [need, []]
+        end
+        
+        unless dependency.kind_of?(Class)
+          dependency = declare(Tap::Task, dependency)
+        end
+  
+        if dependency.ancestors.include?(Tap::Task)
+          [File.basename(dependency.default_name), dependency, argv]
+        else
+          raise ArgumentError, "malformed dependency declaration: #{need}"
+        end
+      end
+      
+      [task_name, configs, needs, arg_names]
+    end
+
+    def arity(block)
+      arity = block.arity
+      
+      case
+      when arity > 0 then arity -= 1
+      when arity < 0 then arity += 1
+      end
+      
+      arity
+    end
+    
+    def declare(klass, name, configs={}, dependencies=[], arg_names=[], &block)
+      # nest the constant name
+      base = (self.kind_of?(Module) ? self : self.class).instance_variable_get(:@tap_declaration_base)
+      name = File.join(base, name.to_s)
+      
+      # generate the subclass
+      subclass = klass.subclass(name, configs, dependencies, &block)
+      
+      # register documentation
+      caller[1] =~ Lazydoc::CALLER_REGEXP
+      subclass.source_file = File.expand_path($1)
+      lazydoc = subclass.lazydoc(false)
+      lazydoc[subclass.to_s]['manifest'] = lazydoc.register($3.to_i - 1, Lazydoc::Declaration)
+
+      if arg_names.empty?
+        arity = block_given? ? arity(block) : -1
+        case 
+        when arity > 0
+          arg_names = Array.new(arity, "INPUT")
+        when arity < 0
+          arg_names = Array.new(-1 * arity - 1, "INPUT")
+          arg_names << "INPUTS..."
+        end
+      end
+      
+      comment = Lazydoc::Comment.new
+      comment.subject = arg_names.join(' ')
+      lazydoc[subclass.to_s]['args'] = comment
+      
+      # update any dependencies in instance
+      subclass.dependencies.each do |dependency, args|
+        subclass.instance.depends_on(dependency.instance, *args)
+      end
+      
+      dir = File.dirname(lazydoc.source_file)
+      manifest = Tap::Env.instance_for(dir).manifest(:tasks).build
+      const_name = subclass.to_s
+      unless manifest.entries.find {|lookup, const| const.name == const_name }
+        manifest.entries << [const_name.underscore, Tap::Support::Constant.new(const_name, lazydoc.source_file)]
+      end
+      
+      subclass
+    end
+  end
+  
+  extend Declarations
+end