bahuvrihi-tap 0.10.2 → 0.10.3

data/cgi/run.rb

@@ -0,0 +1,36 @@
+# ::summary
+# runs a task
+#
+# ::description
+# 
+############################
+require 'cgi'
+require "#{File.dirname(__FILE__)}/../vendor/url_encoded_pair_parser"
+require "tap/support/server/parser"
+
+cgi = CGI.new("html3")  # add HTML generation methods
+
+argh = UrlEncodedPairParser.new(cgi.params.to_a).result
+queues = Tap::Env.instance.build Tap::Support::Server::Parser.new(argh)
+
+cgi.out() do
+  cgi.html() do
+    cgi.head{ cgi.title{ "Tap::Run" } } +
+    cgi.body() do
+      cgi.pre do
+        if queues.empty?
+          
+          "b;ah"
+        else
+          
+          queues.each_with_index do |queue, i|
+            app.queue.concat(queue)
+            app.run
+          end
+          
+          "Ran"
+        end
+      end
+    end
+  end
+end

data/cmd/run.rb

@@ -47,11 +47,12 @@ end.parse!(ARGV)
 #
 # handle options for each specified task
 #
+require 'tap/support/parsers/command_line'
 
-rounds = env.parse(ARGV)
+queues = Tap::Support::Parsers::CommandLine.new(ARGV).build(env, app)
 ARGV.clear
 
-if rounds.empty?
+if queues.empty?
   puts "no task specified"
   exit
 end
@@ -99,7 +100,7 @@ end
 # enque tasks and run!
 #
 
-rounds.each_with_index do |queue, i|
+queues.each_with_index do |queue, i|
   app.queue.concat(queue)
   app.run
 end

data/cmd/server.rb

@@ -0,0 +1,36 @@
+# tap server {options}
+#
+# Initializes a tap server.
+
+require 'tap'
+require 'tap/support/gems/rack'
+
+env = Tap::Env.instance
+
+#
+# handle options
+#
+options = {:Port => 8080}
+OptionParser.new do |opts|
+  
+  opts.separator ""
+  opts.separator "options:"
+
+  opts.on("-h", "--help", "Show this message") do
+    opts.banner = Tap::Support::TDoc.usage(__FILE__)
+    puts opts
+    exit
+  end
+  
+  opts.on("-p", "--port PORT", Integer, "Specifies the port (default #{options[:Port]})") do |value|
+    options[:Port] = value
+  end
+  
+end.parse!(ARGV)
+
+#
+# cgi dir and public dir can be set in tap.yml
+#
+
+env.extend Tap::Support::Gems::Rack
+Rack::Handler::WEBrick.run(env, options)

data/lib/tap/app.rb

@@ -492,7 +492,7 @@ module Tap
     # An Executable may provided instead of a task.
     def enq(task, *inputs)
       case task
-      when Tap::Task, Tap::Workflow
+      when Tap::Task
         raise "not assigned to enqueing app: #{task}" unless task.app == self
         task.enq(*inputs)
       when Support::Executable

data/lib/tap/constants.rb

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

data/lib/tap/env.rb

@@ -273,8 +273,7 @@ module Tap
       @envs = []
       @active = false
       @manifests = {}
-      @manifested = []
-      
+
       # initialize these for reset_env
       @gems = []
       @env_paths = []
@@ -553,6 +552,13 @@ module Tap
       nil
     end
     
+    def reset(name, &block)
+      each do |env|
+        env.manifests[name].each(&block)
+        env.manifests[name] = nil
+      end
+    end
+    
     def constantize(name, *patterns)
       patterns.collect do |pattern| 
         case const = search(name, pattern)

data/lib/tap/exe.rb

@@ -1,9 +1,6 @@
-require 'tap/support/command_line/parser'
-
 module Tap
   class Exe < Env
-    Parser = Support::CommandLine::Parser
-    
+
     class << self
       def instantiate
         app = Tap::App.instance
@@ -66,58 +63,5 @@ module Tap
         end
       end
     end
-    
-    def parse(argv=ARGV)
-      parser = Parser.new(argv)
-      targets = parser.targets
-
-      tasks = []
-      rounds = parser.rounds.collect do |round|
-        round.each do |argv|
-          unless td = Parser.shift_arg(argv)
-            # warn nil?
-            next
-          end
-
-          # attempt lookup the task class
-          const = search(:tasks, td) or raise ArgumentError, "unknown task: #{td}"
-          task_class = const.constantize or raise ArgumentError, "unknown task: #{td}"
-
-          # now let the class handle the argv
-          task, args = task_class.instantiate(argv, app)
-          
-          if !targets.include?(tasks.length)
-            task.enq(*args) 
-          elsif !args.empty?
-            raise ArgumentError, "workflow target receives argv: [#{argv.unshift(td).join(', ')}]" 
-          end
-          
-          tasks << task
-        end
-        
-        app.queue.clear
-      end
-      rounds.delete_if {|round| round.empty? }
-      
-      # build the workflow
-      
-      parser.sequences.each do |sequence|
-        app.sequence(*sequence.collect {|s| tasks[s]})
-      end
-      
-      parser.forks.each do |source, targets|
-        app.fork(tasks[source], *targets.collect {|t| tasks[t]})
-      end
-      
-      parser.merges.each do |target, sources|
-        app.merge(tasks[target], *sources.collect {|s| tasks[s]})
-      end
-      
-      parser.sync_merges.each do |target, sources|
-        app.sync_merge(tasks[target], *sources.collect {|s| tasks[s]})
-      end
-      
-      rounds
-    end
   end
 end

data/lib/tap/support/declarations.rb

@@ -16,56 +16,39 @@ module Tap
       def self.extended(base)
         set_declaration_base(base)
       end
-
-      def tasc(name, configs={}, options={}, &block)
-        Tap::Task.subclass(nest(name), configs, options, &block)
-      end
-
-      def task(name, configs={}, options={}, &block)
-        options[:arity] = arity(block)
-        tasc(name, configs, options, &task_block(block)).new
-      end
-
-      def file_tasc(name, configs={}, options={}, &block)
-        Tap::FileTask.subclass(nest(name), configs, options, &block)
+      
+      def tasc(name, configs={}, &block)
+        declare(Tap::Task, name, configs, &block)
       end
 
-      def file_task(name, configs={}, options={}, &block)
-        options[:arity] = arity(block)
-        file_tasc(nest(name), configs, options, &task_block(block)).new
+      def task(name, configs={}, &block)
+         mod_declare(Tap::Task, name, configs, &block)
       end
 
-      def worcflow(name, configs={}, options={}, &block)
-        Tap::Workflow.subclass(nest(name), configs, options, &block)
+      def file_tasc(name, configs={}, &block)
+        declare(Tap::FileTask, name, configs, &block)
       end
 
-      def workflow(name, configs={}, options={}, &block)
-        options[:arity] = arity(block)
-        worcflow(name, configs, options, &task_block(block)).new
+      def file_task(name, configs={}, &block)
+         mod_declare(Tap::FileTask, name, configs, &block)
       end
-
+      
       protected
 
       def config(key, value=nil, options={}, &block)
-        caller.each do |line|
-          case line
-          when Lazydoc::CALLER_REGEXP
-            options[:desc] = Support::Lazydoc.register($1, $3.to_i - 1)
-            break
-          end
-        end if options[:desc] == nil
+        if options[:desc] == nil
+          caller[0] =~ Lazydoc::CALLER_REGEXP
+          options[:desc] = Support::Lazydoc.register($1, $3.to_i - 1)
+        end 
 
         [:config, key, value, options, block]
       end
 
       def config_attr(key, value=nil, options={}, &block)
-        caller.each do |line|
-          case line
-          when Lazydoc::CALLER_REGEXP
-            options[:desc] = Support::Lazydoc.register($1, $3.to_i - 1)
-            break
-          end
-        end if options[:desc] == nil
+        if options[:desc] == nil
+          caller[0] =~ Lazydoc::CALLER_REGEXP
+          options[:desc] = Support::Lazydoc.register($1, $3.to_i - 1)
+        end
 
         [:config_attr, key, value, options, block]
       end
@@ -75,12 +58,6 @@ module Tap
       end
 
       private
-
-      def nest(name)
-        # use self if self is a Module or Class, 
-        # or self.class if self is an instance.
-        File.join((self.kind_of?(Module) ? self : self.class).instance_variable_get(:@tap_declaration_base), name.to_s)
-      end
       
       def arity(block)
         arity = block.arity
@@ -92,20 +69,65 @@ module Tap
         
         arity
       end
-
-      def task_block(block)
-        lambda do |*inputs|
-          inputs.unshift(self)
-
-          arity = block.arity
-          n = inputs.length
-          unless n == arity || (arity < 0 && (-1-n) <= arity) 
-            raise ArgumentError.new("wrong number of arguments (#{n} for #{arity})")
+      
+      def declare(klass, declaration, configs={}, options={}, &block)
+        # Extract name and dependencies from declaration
+        name, dependencies = case declaration
+        when Hash then declaration.to_a[0]
+        else [declaration, []]
+        end
+        
+        unless dependencies.kind_of?(Array)
+          dependencies = [dependencies]
+        end
+        
+        unless dependencies.empty?
+          dependencies.collect! do |dependency|
+            case dependency
+            when Array then dependency
+            when String, Symbol then [dependency, declare(Tap::Task, dependency)]
+            else 
+              if dependency.kind_of?(Class) && dependency.ancestors.include?(Tap::Task)
+                [File.basename(dependency.default_name), dependency]
+              else
+                raise ArgumentError, "malformed dependency declaration: #{dependency}"
+              end
+            end
           end
+        end
+        
+        # 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)
+        
+        klass.subclass(name, configs, dependencies, options, &block)
+      end
+      
+      def mod_declare(klass, declaration, configs={}, &block)
+        options = {}
+        options[:arity] = arity(block) if block_given?
 
-          block.call(*inputs)
+        subclass = declare(klass, declaration, configs, options)
+        
+        if block_given?
+          mod = Module.new
+          mod.module_eval %Q{
+            ACTION = ObjectSpace._id2ref(#{block.object_id})
+            def process(*args)
+              results = super
+              case ACTION.arity
+              when 0 then ACTION.call
+              when 1 then ACTION.call(self)
+              else ACTION.call(self, *args)
+              end
+              results
+            end
+          }
+          subclass.send(:include, mod)
         end
+        subclass.instance
       end
+
     end
   end
 end

data/lib/tap/support/executable.rb

@@ -2,6 +2,7 @@ require 'tap/support/audit'
 
 module Tap
   module Support
+    
     # Executable wraps methods to make them executable by App.  Methods are 
     # wrapped by extending the object that receives them; the easiest way
     # to make an object executable is to use Object#_method.
@@ -15,7 +16,9 @@ module Tap
 
       # Stores the on complete block.
       attr_reader :on_complete_block
-    
+      
+      attr_reader :dependencies
+      
       public
       
       # Extends obj with Executable and sets up all required variables.  The
@@ -25,9 +28,57 @@ module Tap
         obj.instance_variable_set(:@_method_name, method_name)
         obj.instance_variable_set(:@multithread, multithread)
         obj.instance_variable_set(:@on_complete_block, on_complete_block)
+        obj.instance_variable_set(:@dependencies, [])
         obj
       end
-    
+
+      def self.clear_dependencies
+        @registry = []
+        @results = []
+      end
+      
+      def self.registry
+        @registry
+      end
+      
+      def self.results
+        @results
+      end
+      
+      def self.index(instance, args)
+        @registry.each_with_index do |entry, index|
+          return index if entry[0] == instance && entry[1] == args
+        end
+        nil
+      end
+      
+      def self.resolved?(index)
+        @results[index] != nil
+      end
+      
+      def self.resolve(indicies)
+        indicies.each do |index|
+          next if @results[index]
+          instance, inputs = @registry[index]
+          @results[index] = instance._execute(*inputs)
+        end
+      end
+
+      def self.reset(indicies)
+        indicies.each {|index| @results[index] = nil }
+      end
+      
+      def self.register(instance, args)
+        if existing = index(instance, args)
+          return existing 
+        end
+        
+        @registry << [instance, args]
+        @registry.length - 1
+      end
+      
+      clear_dependencies
+      
       # Sets a block to receive the results of _execute.  Raises an error 
       # if an on_complete block is already set.  Override an existing
       # on_complete block by specifying override = true.
@@ -40,6 +91,30 @@ module Tap
         end
         @on_complete_block = block
       end
+      
+      # Adds the dependency to self, making self dependent on the dependency.
+      # The dependency will be called with the input arguments during 
+      # resolve_dependencies.
+      def depends_on(dependency, *inputs)
+        raise ArgumentError, "not an Executable: #{dependency}" unless dependency.kind_of?(Executable)
+        raise ArgumentError, "cannot depend on self" if dependency == self
+        
+        index = Executable.register(dependency, inputs)
+        dependencies << index unless dependencies.include?(index)
+        index
+      end
+      
+      # Resolves dependencies by calling dependency.resolve with
+      # the dependency arguments.
+      def resolve_dependencies
+        Executable.resolve(dependencies)
+        self
+      end
+      
+      def reset_dependencies
+        Executable.reset(dependencies)
+        self
+      end
 
       # Auditing method call.  Executes _method_name for self, but audits 
       # the result. Sends the audited result to the on_complete_block if set.
@@ -51,7 +126,11 @@ module Tap
       #             a new audit using the input
       # multiple inputs:: merges the inputs into a new Audit.
       #
+      # Dependencies are resolved using resolve_dependencies before
+      # _method_name is executed.
       def _execute(*inputs)
+        resolve_dependencies
+        
         audit = case inputs.length
         when 0 then Audit.new
         when 1