tap 0.19.0 → 1.3.0

data/lib/tap/joins/gate.rb

@@ -0,0 +1,85 @@
+module Tap
+  module Joins
+    
+    # :startdoc::join collects results
+    #
+    # Similar to a synchronized merge, but collects all results regardless of
+    # where they come from.  Gates enque themselves when called as a join, and
+    # won't let results pass until they get run as a task.
+    # 
+    #   % tap load a -- load b - inspect - gate 0,1 2
+    #   ["a", "b"]
+    # 
+    # Gates are useful in conjunction with iteration where a single task may
+    # feed multiple results to a single join; in this case a sync merge doesn't
+    # produce the desired behavior of collecting the results.
+    # 
+    #   % tap load/yaml "[1, 2, 3]" -:i inspect -:.gate inspect
+    #   1
+    #   2
+    #   3
+    #   [1, 2, 3]
+    # 
+    #   % tap load/yaml "[1, 2, 3]" -:i inspect -:.sync inspect
+    #   1
+    #   [1]
+    #   2
+    #   [2]
+    #   3
+    #   [3]
+    # 
+    # When a limit is specified, the gate will collect results up to the limit
+    # and then pass the results.  Any leftover results are still passed at the
+    # end.
+    #
+    #   % tap load/yaml "[1, 2, 3]" -:i inspect - inspect - gate 1 2 --limit 2
+    #   1
+    #   2
+    #   [1, 2]
+    #   3
+    #   [3]
+    #
+    class Gate < Join
+      
+      # An array of results collected thusfar.
+      attr_reader :results
+      
+      config :limit, nil, :short => :l, &c.integer_or_nil   # Pass results after limit
+      
+      def initialize(config={}, app=Tap::App.current)
+        super
+        @results = nil
+      end
+      
+      def call(result)
+        if @results
+          # Results are set, so self is already enqued and collecting
+          # results.  If the input is the collection, then it's time
+          # to execute the results and reset.  Otherwise, just
+          # collect the input and wait.
+          
+          if result == @results
+            @results = nil
+            super(result)
+          else
+            @results << result
+            
+            if limit && @results.length >= limit
+              super(@results.dup)
+              @results.clear
+            end
+          end
+          
+        else
+          # No results are set, so this is a first call and self is
+          # not enqued.  Setup the collection.
+          
+          @results = [result]
+          app.enq(self, @results)
+        end
+        
+        self
+      end
+    end
+  end
+end

data/lib/tap/joins/switch.rb

@@ -1,3 +1,5 @@
+require 'tap/join'
+
 module Tap
   module Joins
     
@@ -16,7 +18,7 @@ module Tap
       # to that receives the result.
       attr_accessor :selector
       
-      def initialize(config={}, app=Tap::App.instance, &block)
+      def initialize(config={}, app=Tap::App.current, &block)
         super(config, app)
         @selector = block
       end
@@ -33,7 +35,7 @@ module Tap
           raise SwitchError, "no switch target at index: #{index}"
         end
 
-        dispatch(output, result)
+        exe(output, result)
       end
       
       # Raised by a Switch join to indicate when a switch index is out of bounds.

data/lib/tap/joins/sync.rb

@@ -1,7 +1,7 @@
 module Tap
   module Joins
     
-    # :startdoc::join a synchronized multi-way join
+    # :startdoc::join synchronized multi-way join
     #
     # Sync works the same as Join, but passes the collected results of the
     # inputs (ie an array) to the outputs. The results will not be passed
@@ -17,7 +17,7 @@ module Tap
       # An array holding results until the batch is ready to execute.
       attr_reader :results
       
-      def initialize(config={}, app=Tap::App.instance)
+      def initialize(config={}, app=Tap::App.current)
         super
         @results = nil
       end
@@ -65,7 +65,7 @@ module Tap
         results[index] = result
         
         unless results.include?(NIL_VALUE)
-          outputs.each {|output| dispatch(output, results) }
+          outputs.each {|output| exe(output, results) }
           reset
         end
       end

data/lib/tap/middleware.rb

@@ -1,9 +1,9 @@
-require 'tap/app'
+require 'tap/app/api'
 
 module Tap
   class Middleware < App::Api
     class << self
-      def build(spec={}, app=Tap::App.instance)
+      def build(spec={}, app=Tap::App.current)
         new(app.stack, spec['config'] || {})
       end
     end
@@ -27,9 +27,9 @@ module Tap
       end
     end
     
-    # By default call simply calls stack with the node and inputs.
-    def call(node, inputs=[])
-      stack.call(node, inputs)
+    # By default call simply calls stack with the task and inputs.
+    def call(task, input)
+      stack.call(task, input)
     end
   end
 end

data/lib/tap/middlewares/debugger.rb

@@ -3,72 +3,32 @@ require 'tap/middleware'
 module Tap
   module Middlewares
     
-    # :startdoc::middleware the default debugger
+    # :startdoc::middleware default debugger
+    #
+    # Logs the execution of tasks with their inputs.  Debugger outputs the
+    # same information as App.exe will output when the app is set to debug. To
+    # avoid duplication, debugger ONLY logs execution when the app is not in
+    # debug mode, or when force is set.
+    #
     class Debugger < Middleware
-      module Utils
-        module_function
-        
-        def arity_ok?(arity, n)
-          n == arity || (arity < 0 && (-1-n) <= arity)
-        end
-      end
-      
-      include Utils
-      
-      config :verbose, false, &c.flag
-      config :output, $stderr, &c.io
+      config :force, false, &c.flag    # Force logging
       
-      def call(node, inputs=[])
-        open_io(output) do |io|
-          io.puts "- - #{node.class}"
-          io.puts "  - #{summarize(inputs)}"
-        end
+      def call(task, input)
+        log("#{app.var(task)} <<", "#{summarize input} (#{task.class})")
+        output = super
         
-        check_signature(node, inputs)
-        super
+        log("#{app.var(task)} >>", "#{summarize output} (#{task.class})")
+        output
       end
       
-      def summarize(inputs)
-        unless verbose
-          inputs = inputs.collect do |input|
-            input.class
-          end
+      def log(action, msg)
+        if force || !app.debug
+          app.log(action, msg)
         end
-        
-        inputs.inspect
       end
       
-      def check_signature(node, inputs)
-        n = inputs.length
-        
-        call_arity = node.method(:call).arity
-        unless arity_ok?(call_arity, n)
-          raise InvalidSignatureError.new(node, inputs, :call, call_arity)
-        end
-        
-        if node.kind_of?(Task)
-          process_arity = node.method(:process).arity
-          unless arity_ok?(process_arity, n)
-            raise InvalidSignatureError.new(node, inputs, :process, process_arity)
-          end
-        end
-        
-        if node.kind_of?(Intern)
-          process_block_arity = node.process_block
-          unless arity_ok?(process_block_arity, n)
-            raise InvalidSignatureError.new(node, inputs, :process_block, process_block_arity)
-          end
-        end
-        
-      end
-      
-      class InvalidSignatureError < StandardError
-        def initialize(node, inputs, method, arity)
-          lines = []
-          lines << "Invalid input signature to: #{node.class} (#{method})"
-          lines << "Expected #{arity} input but was given #{inputs.length}" 
-          super(lines.join("\n"))
-        end
+      def summarize(obj)
+        obj.inspect
       end
     end
   end

data/lib/tap/parser.rb

@@ -1,74 +1,35 @@
-require 'shellwords'
+require 'tap/join'
+require 'tap/tasks/signal'
 
 module Tap
   
   # A parser for workflows defined on the command line.
   class Parser
-    class << self
-      def parse(argv=ARGV)
-        parse!(argv.dup)
-      end
-      
-      def parse!(argv=ARGV)
-        argv = Shellwords.shellwords(argv) if argv.kind_of?(String)
-        sig, obj = argv.shift, nil
-        
-        if sig =~ OBJECT
-          obj, sig = $1, $2
-        end
-        
-        [obj, sig, argv]
-      end
-    end
     
-    # The escape begin argument
-    ESCAPE_BEGIN = "-."
-
-    # The escape end argument
-    ESCAPE_END = ".-"
-
-    # The parser end flag
-    END_FLAG = "---"
-  
-    # Matches any breaking arg. Examples:
-    #
-    #   --
-    #   --:
-    #   --[1,2][3]
-    #   --@
-    #   --/var
-    #   --.
-    #
-    # After the match:
-    #
-    #   $1:: The string after the break, or nil
-    #        (ex: '--' => nil, '--:' => ':', '--[1,2][3,4]' => '[1,2][3,4]')
-    #
-    BREAK =  /\A--(?:\z|([\:\[\/\.@].*?)\z)/
-  
-    # The node modifier.
-    NODE_BREAK = nil
-  
-    # The join modifier.
-    JOIN_BREAK = "."
-  
+    # Regexp to match any dash-nonword break
+    BREAK = /\A-(?!-?\w)/
+    
+    # Matches a traditional dash-letter or double-dash-word option
+    OPTION = /\A--?\w/
+    
+    # Delmits and sets the next object
+    SET = '-'
+    
+    # Sets and enques the next object
+    ENQUE = '--'
+    
+    # Sets and executes the next object
+    EXECUTE = '-!'
+    
+    # Break to enque an existing object
+    SIGENQ = '-@'
+    
     # Matches a sequence break. After the match:
     #
     #   $1:: The modifier string, or nil
     #        (ex: ':' => nil, ':i' => 'i')
     #
-    SEQUENCE = /\A:(.+)?\z/
-  
-    # Matches a generic join break. After the match:
-    #
-    #   $1:: The inputs string.
-    #        (ex: '[1,2,3][4,5,6]' => '1,2,3')
-    #   $2:: The outputs string.
-    #        (ex: '[1,2,3][4,5,6]' => '4,5,6')
-    #   $3:: The modifier string, or nil
-    #        (ex: '[][]is' => 'is')
-    #
-    JOIN = /\A\[(.*?)\]\[(.*?)\](.+)?\z/
+    JOIN = /\A-:(.+)?\z/
   
     # Matches a join modifier. After the match:
     #
@@ -77,14 +38,7 @@ module Tap
     #   $2:: The class string.
     #        (ex: 'is.sync' => 'sync')
     #
-    JOIN_MODIFIER = /\A([A-z]*)(?:\.(.*))?\z/
-  
-    # Matches an enque modifier. After the match:
-    #
-    #   $1:: The modifier string, or nil
-    #        (ex: '@var' => 'var')
-    #
-    ENQUE = /\A@(.+)?\z/
+    MODIFIER = /\A([A-z]*)(?:\.(.*))?\z/
     
     # Matches a signal break. After the match:
     #
@@ -93,49 +47,39 @@ module Tap
     #   $2:: The signal string
     #        (ex: 'obj/sig' => 'sig')
     #
-    SIGNAL = /\A\/(?:(.*)\/)?(.*)\z/
+    SIGNAL = /\A-(-)?\/(.*)\z/
     
-    # Splits a signal into an object string and a signal string.  If OBJECT
-    # doesn't match, then the string can be considered a signal, and the
-    # object is nil. After a match:
-    #
-    #   $1:: The object string
-    #        (ex: 'obj/sig' => 'obj')
-    #   $2:: The signal string
-    #        (ex: 'obj/sig' => 'sig')
-    #
-    OBJECT = /\A(.*)\/(.*)\z/
+    # The escape begin argument
+    ESCAPE_BEGIN = "-."
+
+    # The escape end argument
+    ESCAPE_END = ".-"
+
+    # The parser end flag
+    END_FLAG = "---"
     
     attr_reader :specs
     
-    def initialize(specs=[])
-      @specs = specs
+    def initialize
+      @specs = []
     end
     
     def parse(argv)
-      argv = argv.dup unless argv.kind_of?(String)
-      parse!(argv)
+      parse!(argv.dup)
     end
 
     # Same as parse, but removes parsed args from argv.
     def parse!(argv)
-      argv = Shellwords.shellwords(argv) if argv.kind_of?(String)
       return argv if argv.empty?
       
-      unless argv[0] =~ BREAK
-        argv.unshift("--") 
-      end
-      
-      @current_type = nil
       @current_index = -1
-      @current = nil
+      current = argv[0] =~ BREAK ? nil : spec(:enq)
       escape = false
       
       while !argv.empty?
         arg = argv.shift
 
-        # if escaping, add escaped arguments 
-        # until an escape-end argument
+        # collect escaped arguments until an escape-end
         if escape
           if arg == ESCAPE_END
             escape = false
@@ -144,125 +88,113 @@ module Tap
           end
           next
         end
-      
-        # handle breaks and parser flags
-        case arg
-        when BREAK
-          begin
-            @current_type = nil
-            @current_index += 1
-            @current = parse_break($1)
-          rescue
-            raise "invalid break: #{arg} (#{$!.message})"
-          end
-          next
-
-        when ESCAPE_BEGIN
-          escape = true
+        
+        # collect non-option/break arguments
+        unless arg[0] == ?-
+          current << arg
           next
-
-        when END_FLAG
-          break
+        end
         
-        end if arg[0] == ?-
+        begin
+          
+          # parse option/break arguments
+          case arg
+          when SET
+            current = spec(:set)
+          when ENQUE
+            current = spec(:enq)
+          when EXECUTE
+            current = spec(:exe)
+          when OPTION
+            current << arg
+          when JOIN
+            current = parse_join($1)
+          when SIGENQ
+            current = parse_signal(nil, 'enq')
+          when SIGNAL
+            current = parse_signal($1, $2)
+          when ESCAPE_BEGIN
+            escape = true
+          when END_FLAG
+            break
+          else
+            raise "unknown"
+          end
+          
+        rescue
+          raise "invalid break: #{arg} (#{$!.message})"
+        end
+      end
       
-        # add all remaining args to the current argv
-        current << arg
+      argv
+    end
+    
+    def build_to(app)
+      blocks = Hash.new do |hash, type|
+        hash[type] = block(type, app)
       end
       
-      @current_type = nil
-      @current_index = nil
-      @current = nil
+      app.scope do
+        specs.each do |(spec, type)|
+          app.call(spec, &blocks[type])
+        end
+      end
       
-      argv
+      self
     end
     
     private
     
-    def spec(*argv) # :nodoc:
-      specs << argv
-      argv
+    def next_args # :nodoc:
+      @current_index += 1
+      [@current_index.to_s]
     end
     
-    # returns the current argv or a new spec argv for the current type/index
-    def current # :nodoc:
-      @current ||= spec(@current_type, nil, 'set', @current_index.to_s)
+    def spec(type, args=next_args) # :nodoc:
+      specs << [{'sig' => 'set', 'args' => args}, type]
+      args
     end
-  
-    # determines the type of break and modifies self appropriately
-    def parse_break(one) # :nodoc:
-      case one
-      when NODE_BREAK
-        set_type(:node)
-      when JOIN_BREAK
-        set_type(:join)
-      when SEQUENCE
-        parse_sequence($1)
-      when JOIN
-        parse_join($1, $2, $3)
-      when ENQUE
-        parse_enque($1)
-      when SIGNAL
-        parse_signal($1, $2)
+    
+    def block(type, app) # :nodoc:
+      case type
+      when :enq
+        lambda {|obj, args| app.queue.enq(obj, args); obj }
+      when :exe
+        lambda {|obj, args| app.exe(obj, args); obj }
       else
-        raise "invalid modifier"
+        nil
       end
     end
-    
-    # sets the type of the next spec
-    def set_type(type) # :nodoc:
-      @current_type = type
-      nil
-    end
-    
-    # parses the match of a SEQUENCE regexp
-    def parse_sequence(one) # :nodoc:
-      unless @current_index > 0
+      
+    # parses the match of a JOIN regexp
+    def parse_join(one) # :nodoc:
+      if @current_index < 0
         raise "no prior entry"
       end
       
-      @current_type = :node
-      @current = nil
-      argv = current
-      parse_join_spec(one, "#{@current_index - 1}", @current_index.to_s)
-      argv
-    end
-    
-    # parses the match of a JOIN regexp
-    def parse_join(one, two, three) # :nodoc:
-      parse_join_spec(three, one, two)
-    end
-    
-    # parses a join modifier string into an argv.
-    def parse_join_spec(modifier, inputs, outputs) # :nodoc:
-      argv = [:join, nil, 'set', nil]
+      current = spec(:set)
+      join = spec(:set, [nil])
       
-      case 
-      when modifier.nil?
-        argv << 'tap:join'
-        argv << inputs
-        argv << outputs
-      when modifier =~ JOIN_MODIFIER
-        argv << ($2 || 'join')
-        argv << inputs
-        argv << outputs
-        $1.split("").each {|char| argv << "-#{char}"}
+      case one
+      when nil
+        join << Tap::Join
+      when MODIFIER
+        join << ($2 || Tap::Join)
+        $1.split('').each {|flag| join << "-#{flag}"}
       else
         raise "invalid join modifier"
       end
       
-      specs << argv
-      argv
-    end
-    
-    # parses the match of an ENQUE regexp
-    def parse_enque(one) # :nodoc:
-      spec(:signal, nil, 'enque', one)
+      join << (@current_index - 1).to_s
+      join << @current_index.to_s
+      
+      current
     end
     
     # parses the match of a SIGNAL regexp
     def parse_signal(one, two) # :nodoc:
-      spec(:signal, one, two)
+      next_args
+      spec(one.nil? ? :enq : :exe, [nil, Tap::Tasks::Signal, two, '--'])
     end
   end
 end