bahuvrihi-tap 0.10.6 → 0.10.7

data/lib/tap/support/executable.rb

@@ -1,5 +1,4 @@
 require 'tap/support/audit'
-require 'tap/support/dependable'
 
 module Tap
   module Support
@@ -8,7 +7,9 @@ module Tap
     # wrapped by extending the object that receives them; the easiest way
     # to make an object executable is to use Object#_method.
     module Executable
-      extend Dependable
+      
+      # The Tap::App the Executable belongs to.
+      attr_reader :app
       
       # The method called when an Executable is executed via _execute
       attr_reader :_method_name
@@ -19,57 +20,258 @@ module Tap
       # An array of dependency indexes that will be resolved on _execute
       attr_reader :dependencies
       
+      # The batch for the Executable.
+      attr_reader :batch
+      
       public
       
       # Extends obj with Executable and sets up all required variables.  The
       # specified method will be called on _execute.
-      def self.initialize(obj, method_name, &on_complete_block)
+      def self.initialize(obj, method_name, app=App.instance, batch=[], dependencies=[], &on_complete_block)
         obj.extend Executable
+        obj.instance_variable_set(:@app, app)
         obj.instance_variable_set(:@_method_name, method_name)
         obj.instance_variable_set(:@on_complete_block, on_complete_block)
-        obj.instance_variable_set(:@dependencies, [])
+        obj.instance_variable_set(:@dependencies, dependencies)
+        obj.instance_variable_set(:@batch, batch)
+        batch << obj
+        
         obj
       end
       
-      # 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.
+      # Initializes a new batch object and adds the object to batch.
+      # The object will be a duplicate of self.  (Note this method
+      # can raise an error for objects that don't support dup, like
+      # methods generated by Object#_method).
+      def initialize_batch_obj
+        obj = self.dup
+        
+        if obj.kind_of?(Executable)
+          batch << obj
+          obj
+        else
+          Executable.initialize(obj, _method_name, app, batch, dependencies, &on_complete_block)
+        end
+      end
+      
+      # Returns true if the batch size is greater than one 
+      # (the one being self).  
+      def batched?
+        batch.length > 1
+      end
+
+      # Returns the index of the self in batch.
+      def batch_index
+        batch.index(self)
+      end
+      
+      # Merges the batches for self and the specified Executables,
+      # removing duplicates.
+      #
+      #   class BatchExecutable
+      #     include Tap::Support::Executable
+      #     def initialize(batch=[])
+      #       @batch = batch
+      #       batch << self
+      #     end
+      #   end
+      #
+      #   b1 = BatchExecutable.new
+      #   b2 = BatchExecutable.new
+      #   b3 = BatchExecutable.new
+      #
+      #   b1.batch_with(b2, b3)
+      #   b1.batch                   # => [b1, b2, b3]
+      #   b3.batch                   # => [b1, b2, b3]
+      #
+      # Note that batch_with is not recursive (ie it does not 
+      # merge the batches of each member in the batch):
+      #
+      #   b4 = BatchExecutable.new
+      #   b4.batch_with(b3)   
+      #            
+      #   b4.batch                   # => [b4, b1, b2, b3]
+      #   b3.batch                   # => [b4, b1, b2, b3]
+      #   b2.batch                   # => [b1, b2, b3]
+      #   b1.batch                   # => [b1, b2, b3]
+      #
+      # However it does affect all objects that share the same
+      # underlying batch:
+      #
+      #   b5 = BatchExecutable.new(b1.batch)
+      #   b6 = BatchExecutable.new
+      #
+      #   b5.batch.object_id         # => b1.batch.object_id
+      #   b5.batch                   # => [b1, b2, b3, b5]
+      #
+      #   b5.batch_with(b6)
+      #
+      #   b5.batch                   # => [b1, b2, b3, b5, b6]
+      #   b1.batch                   # => [b1, b2, b3, b5, b6]
+      #
+      # Returns self.
+      def batch_with(*executables)
+        batches = [batch] + executables.collect {|executable| executable.batch }
+        batches.uniq!
+        
+        merged = []
+        batches.each do |batch| 
+          merged.concat(batch)
+          batch.clear
+        end
+        
+        merged.uniq!
+        batches.each {|batch| batch.concat(merged) }
+        self
+      end
+      
+      # Enqueues self and self.batch to app with the inputs. The number 
+      # of inputs provided should match the number of inputs specified 
+      # by the arity of the _method_name method.
+      def enq(*inputs)
+        batch.each do |executable| 
+          executable.unbatched_enq(*inputs)
+        end
+        self
+      end
+      
+      # Like enq, but only enques self.
+      def unbatched_enq(*inputs)
+        app.queue.enq(self, inputs)
+        self
+      end
+      
+      # 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.
       #
       # Note the block recieves an audited result and not
       # the result itself (see Audit for more information).
       def on_complete(override=false, &block) # :yields: _result
+        batch.each do |executable| 
+          executable.unbatched_on_complete(override, &block)
+        end
+        self
+      end
+      
+      # Like on_complete, but only sets on_complete_block for self.
+      def unbatched_on_complete(override=false, &block) # :yields: _result
         unless on_complete_block == nil || override
           raise "on_complete_block already set: #{self}" 
         end
         @on_complete_block = block
+        self
       end
       
-      # Adds the dependency to self, making self dependent on the dependency.
-      # The dependency will be resolved by calling dependency._execute with 
-      # the input arguments during resolve_dependencies.
-      def depends_on(dependency, *inputs)
+      # 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, &block) # :yields: _result
+        Joins::Sequence.join(self, tasks, &block)
+      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(*targets, &block) # :yields: _result
+        Joins::Fork.join(self, targets, &block)
+      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(*sources, &block) # :yields: _result
+        Joins::Merge.join(self, sources, &block)
+      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)
+      # 
+      # - note stacking with a sync merge is *somewhat* pointless;
+      #   it does not change the run order, but of course it does
+      #   allow other tasks to be interleaved.
+      #
+      def sync_merge(*sources, &block) # :yields: _result
+        Joins::SyncMerge.join(self, sources, &block)
+      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(*targets, &block) # :yields: _result
+        Joins::Switch.join(self, targets, &block)
+      end
+      
+      def unbatched_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)
+        index = app.dependencies.register(dependency, inputs)
         dependencies << index unless dependencies.include?(index)
         index
       end
       
+      # Adds the dependency to self, making self dependent on the dependency.
+      # The dependency will be resolved by calling dependency._execute with 
+      # the input arguments during resolve_dependencies.
+      def depends_on(dependency, *inputs)
+        index = unbatched_depends_on(dependency, *inputs)
+        batch.each do |e| 
+          e.dependencies << index unless e.dependencies.include?(index)
+        end
+        index
+      end
+      
       # Resolves dependencies by calling dependency._execute with
       # the dependency arguments.  (See Dependable#resolve).
       def resolve_dependencies
-        Executable.resolve(dependencies)
+        app.dependencies.resolve(dependencies)
         self
       end
       
       # Resets dependencies so they will be re-resolved on resolve_dependencies.
       # (See Dependable#reset).
       def reset_dependencies
-        Executable.reset(dependencies)
+        app.dependencies.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.
       #
@@ -110,10 +312,15 @@ module Tap
         end
       
         audit._record(self, send(_method_name, *inputs))
-        on_complete_block.call(audit) if on_complete_block
-      
+        on_complete_block ? on_complete_block.call(audit) : app.aggregator.store(audit)
+        
         audit
       end
+      
+      def inspect
+        "#<#{self.class.to_s}:#{object_id} _method: #{_method_name} batch_length: #{batch.length} app: #{app}>"
+      end
+      
     end
   end
 end
@@ -137,8 +344,8 @@ class Object
   # Initializes a Tap::Support::Executable using the Method returned by
   # Object#method(method_name), setting the on_complete block as specified.  
   # Returns nil if Object#method returns nil.
-  def _method(method_name, &on_complete_block) # :yields:  _result
+  def _method(method_name, app=Tap::App.instance) # :yields:  _result
     return nil unless m = method(method_name)
-    Tap::Support::Executable.initialize(m, :call, &on_complete_block)
+    Tap::Support::Executable.initialize(m, :call, app)
   end
 end

data/lib/tap/support/gems/rake.rb

@@ -21,8 +21,11 @@ module Tap
       
         attr_accessor :env
        
-        def collect_tasks
-          ARGV.collect! do |arg|
+        def collect_tasks(*args)
+          # a little song and dance for compliance with
+          # rake pre- and post-0.8.2
+          argv = args.empty? ? ARGV : args[0]
+          argv.collect! do |arg|
             next(arg) unless arg =~ /^:([a-z_\d]+):(.*)$/
             env_pattern = $1
             rake_task = $2
@@ -55,7 +58,7 @@ module Tap
               fail "No Rakefile found for '#{env_pattern}' (looking for: #{@rakefiles.join(', ')})"
             end
           end
-        
+          
           super
         end
       

data/lib/tap/support/join.rb

@@ -0,0 +1,87 @@
+module Tap
+  module Support
+    class Join
+      class << self
+        def join(source, targets, &block)
+          options = targets[-1].kind_of?(Hash) ? targets.pop : {}
+          new(options).join(source, targets, &block)
+        end
+      end
+      
+      include Configurable
+      
+      config :iterate, false, &c.boolean
+      config :stack, false, &c.boolean
+      config :unbatched, false, &c.boolean
+      
+      # An array of workflow flags.  All 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]}
+
+      def initialize(options)
+        initialize_config(options)
+      end
+      
+      def name
+        self.class.to_s =~ /.*::(.*)$/
+        $1.underscore.to_sym
+      end
+      
+      def options
+        opts = config.to_hash
+        opts.delete_if {|key, value| value == false }
+        opts
+      end
+      
+      def inspect
+        "#<Join:#{object_id}>"
+      end
+      
+      protected
+      
+      def complete(executable, &block)
+        executable.send(unbatched ? :unbatched_on_complete : :on_complete, &block)
+      end
+      
+      def enq(executable, _results)
+        app = executable.app
+        
+        results = iterate ? _results._expand : [_results]
+        results.each do |_result|
+          if stack 
+      
+            if unbatched
+              executable.unbatched_enq(_result)
+            else
+              executable.enq(_result)
+            end
+      
+          else
+      
+            if unbatched
+              app.execute(executable, _result)
+            else
+              executable.batch.each do |e|
+                app.execute(e, _result)
+              end
+            end
+      
+          end
+        end
+      end
+    end
+    
+    class ReverseJoin < Join
+      def join(target, sources, &block)
+        options = sources[-1].kind_of?(Hash) ? sources.pop : {}
+        new(options).join(target, sources, &block)
+      end
+      
+      def inspect
+        "#<ReverseJoin:#{object_id}>"
+      end
+    end
+  end
+end

data/lib/tap/support/joins.rb

@@ -0,0 +1,13 @@
+require 'tap/support/join'
+
+module Tap
+  module Support
+    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
+  end
+end

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

@@ -0,0 +1,18 @@
+module Tap
+  module Support
+    module Joins
+      
+      class Fork < Join
+        def join(source, targets)
+          complete(source) do |_result|
+            targets.each do |target| 
+              yield(_result) if block_given?
+              enq(target, _result)
+            end
+          end
+        end
+      end
+
+    end
+  end
+end