tap 0.11.1 → 0.12.0

data/lib/tap/support/gems.rb

@@ -7,7 +7,7 @@ module Tap
     # and other gems frequently used by Tap.
     module Gems
       module_function
-
+      
       # Returns the gemspec for the specified gem.  A gem version 
       # can be specified in the name, like 'gem >= 1.2'.  The gem 
       # will be activated using +gem+ if necessary.

data/lib/tap/support/intern.rb

@@ -5,8 +5,6 @@ module Tap
     # An Intern module:
     # - adds an accessor for <method_name>_block
     # - overrides <method_name> to call the block
-    # - ensures initialize_batch_obj extends the batch object
-    #   with the same Intern module
     #
     def self.Intern(method_name)
       mod = INTERN_MODULES[method_name.to_sym]
@@ -28,10 +26,6 @@ module Tap
       
         #{method_name}_block.call(*inputs)
       end
-      
-      def initialize_batch_obj(*args)
-        super(*args).extend Tap::Support::Intern(:#{method_name})
-      end
       }
       mod
     end

data/lib/tap/support/join.rb

@@ -1,3 +1,5 @@
+require 'configurable'
+
 module Tap
   module Support
     
@@ -6,56 +8,42 @@ module Tap
     # variety of configurations which affect how one task passes inputs
     # to subsequent tasks.
     #
-    # Joins have a single source and may have multiple targets.  See
-    # ReverseJoin for joins with a single target and multiple sources.
     class Join
-      class << self
-        
-        # Create a join between the source and targets.  Targets should
-        # be an array; if the last member of targets is a hash, it will
-        # be used as the configurations for the join.
-        def join(source, targets, &block)
-          options = targets[-1].kind_of?(Hash) ? targets.pop : {}
-          new(options).join(source, targets, &block)
-        end
-      end
-      
       include Configurable
       
       # 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
-      
-      # Causes joins to only occur between the
-      # explicitly named source and targets,
-      # and not their batches.
-      config :unbatched, false, &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]}
+      config :stack, false, :short => 'k', &c.boolean
       
       # Initializes a new join with the specified configuration.
-      def initialize(config)
+      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
       
-      # Creates a join between the source and targets.
-      # Must be implemented in subclasses.
-      def join(source, targets, &block)
-        raise NotImplementedError
+      # Creates a join that passes the results of each input to each output.
+      def join(inputs, outputs)
+        inputs.each do |input|
+          input.on_complete do |_result|
+            outputs.each do |output| 
+              yield(_result) if block_given?
+              enq(output, _result)
+            end
+          end
+        end
       end
       
       # A hash of the configurations set to true.
@@ -72,71 +60,49 @@ module Tap
       
       protected
       
-      # Sets the on_complete block for the specified executable.
-      # If unbatched == true, the on_complete block will only 
-      # be set for the executable; otherwise the on_complete
-      # block will be set for executable.batch.
-      def complete(executable, &block)
-        executable.send(unbatched ? :unbatched_on_complete : :on_complete, &block)
-      end
-      
       # Enques the executable with the results, respecting the
       # configuration for self.
       #
       #                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)
-            else
-              executable.enq(_result)
-            end
-      
+            executable.enq(*_result)
           else
-      
-            if unbatched
-              executable._execute(_result)
-            else
-              executable.batch.each do |e|
-                e._execute(_result)
-              end
-            end
-      
+            executable._execute(*_result)
           end
         end
       end
-    end
-    
-    # Like a Join, but with a single target and multiple sources.
-    class ReverseJoin < Join
-      class << self
-        # Create a join between the sources and target.  Sources should
-        # be an array; if the last member of sources is a hash, it will
-        # be used as the configurations for the join.
-        def join(target, sources, &block)
-          options = sources[-1].kind_of?(Hash) ? sources.pop : {}
-          new(options).join(target, sources, &block)
-        end
-      end
       
-      # Creates a join between the sources and target.
-      # Must be implemented in subclasses.
-      def join(target, sources, &block)
-        raise NotImplementedError
+      # 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
       
-      # Returns a string like: "#<ReverseJoin:object_id>"
-      def inspect
-        "#<ReverseJoin:#{object_id}>"
+      # 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
   end

data/lib/tap/support/joins.rb

@@ -5,9 +5,6 @@ module Tap
     
     # A module of the standard Join classes supported by Tap.
     module Joins
-      autoload(:Sequence, 'tap/support/joins/sequence')
-      autoload(:Fork, 'tap/support/joins/fork')
-      autoload(:Merge, 'tap/support/joins/merge')
       autoload(:SyncMerge, 'tap/support/joins/sync_merge')
       autoload(:Switch, 'tap/support/joins/switch')  
     end

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

@@ -2,19 +2,21 @@ module Tap
   module Support
     module Joins
       
-      # A Switch join allows a block to determine which target from
-      # set of targets will receive the results of the source.
+      # A Switch join allows a block to determine which output from an array
+      # of outputs will receive the results of the input.
       class Switch < Join
-        def join(source, targets)
-          complete(source) do |_result| 
-            if index = yield(_result)        
-              unless target = targets[index] 
-                raise "no switch target for index: #{index}"
-              end
+        def join(inputs, outputs)
+          inputs.each do |input|
+            input.on_complete do |_result| 
+              if index = yield(_result)        
+                unless output = outputs[index] 
+                  raise "no switch target for index: #{index}"
+                end
 
-              enq(target, _result)
-            else
-              source.app.aggregator.store(_result)
+                enq(output, _result)
+              else
+                input.app.aggregator.store(_result)
+              end
             end
           end
         end

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

@@ -1,63 +1,38 @@
 module Tap
   module Support
-    autoload(:Combinator, 'tap/support/combinator')
-    
     module Joins
       
-      # SyncMerge passes the collected results of the sources to the target. The
-      # results will not be passed until results from all of the sources are 
+      # SyncMerge passes the collected results of the inputs to the outputs. The
+      # results will not be passed until results from all of the inputs are 
       # available; results are passed in one group.  Similarly, a collision 
-      # results if a single source completes twice before the group.
-      class SyncMerge < ReverseJoin
-        def join(target, sources)
-
-          # a hash of (source, index) pairs where index is the
-          # index of the source in a combination
-          indicies = {}
-
-          # a hash of (source, combinations) pairs where combinations
-          # are combination arrays that the source participates in.
-          # note that in unbatched mode, some sources may not
-          # participate in any combinations.
-          combinations = {}
-
-          sets = sources.collect {|source| unbatched ? [source] : source.batch }
-          Support::Combinator.new(*sets).each do |combo|
-            combination = Array.new(combo.length, nil)
-
-            combo.each do |source|
-              indicies[source] ||= combo.index(source)
-              (combinations[source] ||= []) << combination
-            end
-          end
-
-          sources.each_with_index do |source, index|
-            complete(source) do |_result|
-              src = _result._current_source
-
-              source_index = indicies[src]
-              (combinations[src] ||= []).each do |combination|
-                if combination[source_index] != nil
-                  raise "sync_merge collision... already got a result for #{src}"
-                end
-
-                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)
-
-                  # reset the group array
-                  combination.collect! {|i| nil }
-                end
+      # results if a single input completes twice before the group completes as
+      # a whole.
+      class SyncMerge < Join
+        
+        def join(inputs, outputs)
+          results = Array.new(inputs.length)
+          
+          inputs.each do |input|
+            input.on_complete do |_result|
+              index = inputs.index(_result.key)
+              
+              unless results[index] == nil
+                raise "sync_merge collision... already got a result for #{inputs[index]}"
+              end
+              results[index] = _result
+              
+              unless results.include?(nil)
+                yield(*results) if block_given?
+                outputs.each {|output| enq(output, *results) }
+                
+                # reset the results array
+                results.collect! {|i| nil }
               end
             end
           end
         end
+        
       end
-
     end
   end
 end

data/lib/tap/support/manifest.rb

@@ -1,4 +1,5 @@
 require 'tap/support/minimap'
+require 'tap/support/intern'
 
 module Tap
   module Support

data/lib/tap/support/node.rb

@@ -3,41 +3,156 @@ module Tap
 
     # Represents a task node in a Schema.
     class Node
+      class << self
+        
+        # Returns the natural round of a set of nodes.  The natural round is
+        # the lowest round of any of the nodes, or the node ancestors.
+        #
+        #   # (3)-o-[A]-o-[C]-o-[D]
+        #   #           |
+        #   # (2)-o-[B]-o
+        #
+        #   join1, join2 = Array.new(2) { [:join, [], []] }
+        #   a = Node.new [], 3, join1
+        #   b = Node.new [], 2, join1
+        #   c = Node.new [], join1, join2
+        #   d = Node.new [], join2
+        #
+        #   Node.natural_round([d])              # => 2
+        #
+        # Tracking back, the natural round of D is 2.  Node order does not
+        # matter and globals are ignored.
+        #
+        #   # ( )-o-[E]-o
+        #   #           |
+        #   # (1)-o-[F]-o
+        #   #           |
+        #   # (2)-o-[G]-o-[H]
+        #
+        #   join = [:join, [], []]
+        #   e = Node.new [], nil, join
+        #   f = Node.new [], 1, join
+        #   g = Node.new [], 2, join
+        #   h = Node.new [], join
+        #
+        #   Node.natural_round([d, h])           # => 1
+        #
+        def natural_round(nodes, visited=[])
+          round = nil
+          nodes.each do |node|
+            next if visited.include?(node)
+            visited << node
+            
+            case input = node.input
+            when Integer
+              
+              # reassign current round if necesssary
+              unless round && round < input
+                round = input
+              end
+              
+            when Array
+              round = natural_round(node.parents, visited)
+            end
+            
+            # optimization; no round is less than 0
+            return 0 if round == 0
+          end
+          
+          round || 0
+        end
+      end
       
-      # An array of arguments used to instantiate
-      # the node
+      # An array of arguments used to instantiate the node
       attr_accessor :argv
       
-      # The input or source for the node.  Inputs
-      # may be a Join, nil, or an Integer.  An 
-      # Integer input indicates that the node should 
-      # be enqued to a round using argv as inputs.
-      attr_accessor :input
+      # The input for the node.  Input may be:
+      #
+      # - a join array: [join_instance, input_nodes, output_nodes]
+      # - an Integer indicating the round for self
+      # - nil signifiying 'global'
+      #
+      attr_reader :input
       
-      # The output for the node. Output may be a
-      # a Join or nil.
-      attr_accessor :output
+      # The output for the node.  Output may be:
+      #
+      # - a join array: [join_instance, input_nodes, output_nodes]
+      # - nil signifying nothing
+      #
+      attr_reader :output
 
-      def initialize(argv=[], input=nil, output=nil)
+      def initialize(argv=[], input=0, output=nil)
         @argv = argv
-        @input = input
-        @output = output
+        @input = @output = nil
+        
+        self.input = input
+        self.output = output
+      end
+      
+      def input_join
+        input.kind_of?(Array) ? input : nil
+      end
+      
+      def output_join
+        output.kind_of?(Array) ? output : nil
+      end
+      
+      # Returns an array of nodes that pass inputs to self via an input join.
+      # If input is not a join, parents is an empty array.
+      def parents
+        input.kind_of?(Array) ? input[1] : []
       end
       
-      # Resets the source and join to nil.
+      # Returns an array of nodes that receive the outputs self via an output
+      # join.  If output is not a join, children is an empty array.
+      def children
+        output.kind_of?(Array) ? output[2] : []
+      end
+      
+      # Sets the input for self.
+      def input=(value)
+        if input.kind_of?(Array)
+          input[2].delete(self)
+        end
+        
+        if value.kind_of?(Array)
+          value[2] << self
+        end
+        
+        @input = value
+      end
+      
+      # Sets the output for self.
+      def output=(value)
+        if output.kind_of?(Array)
+          output[1].delete(self)
+          
+          # cleanup orphan joins
+          if output[1].empty?
+            orphan_round = natural_round
+            output[2].dup.each {|node| node.input = orphan_round }
+          end
+        end
+        
+        if value.kind_of?(Array)
+          value[1] << self
+        end
+        
+        @output = value
+      end
+      
+      # Sets the input to nil.
       def globalize
         self.input = nil
-        self.output = nil
       end
       
-      # True if the input and output are nil.
+      # True if the input is nil.
       def global?
-        input == nil && output == nil
+        input == nil
       end
       
-      # Returns the round for self; a round is indicated
-      # by an integer input.  If input is anything but 
-      # an integer, round returns nil.
+      # Returns the round for self; a round is indicated by an integer input. 
+      # If input is anything but an integer, round returns nil.
       def round
         input.kind_of?(Integer) ? input : nil
       end
@@ -47,6 +162,11 @@ module Tap
         self.input = input
       end
       
+      # Returns the natural round for self.
+      def natural_round
+        Node.natural_round([self])
+      end
+      
       def inspect
         "#<#{self.class}:#{object_id} argv=[#{argv.join(' ')}] input=#{input.inspect} output=#{output.inspect}>"
       end