tap 0.12.4 → 0.17.0

data/lib/tap/support/gems.rb

@@ -1,43 +0,0 @@
-require 'rubygems'
-
-module Tap
-  module Support
-    
-    # Methods for working with {RubyGems}[http://www.rubygems.org/] 
-    # 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.
-      def gemspec(gem_name)
-        return gem_name if gem_name.kind_of?(Gem::Specification)
-        
-        # figure the version of the gem, by default >= 0.0.0
-        gem_name.to_s =~ /^([^<=>]*)(.*)$/
-        name, version = $1.strip, $2
-        version = ">= 0.0.0" if version.empty?
-        
-        return nil if name.empty?
-        
-        # load the gem and get the spec
-        gem(name, version)
-        Gem.loaded_specs[name]
-      end
-      
-      # Selects gem specs for which the block returns true.  If
-      # latest is specified, only the latest version of each
-      # gem will be passed to the block.
-      def select_gems(latest=true)
-        index = latest ?
-          Gem.source_index.latest_specs :
-          Gem.source_index.gems.collect {|(name, spec)| spec }
-        
-        index.select do |spec|
-          yield(spec)
-        end.sort
-      end
-    end
-  end
-end

data/lib/tap/support/join.rb

@@ -1,144 +0,0 @@
-require 'configurable'
-
-module Tap
-  module Support
-    
-    # Joins create on_complete blocks which link together tasks (or more
-    # generally, Executable objects) into workflows.  Joins support a 
-    # variety of configurations which affect how one task passes inputs
-    # to subsequent tasks.
-    #
-    class Join
-      include Configurable
-      
-      # Causes the join to iterate the results
-      # of the source when enquing the targets.
-      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, :short => 'k', &c.boolean
-      
-      # Aggregates results and enques them to the target
-      # in a trailing round.
-      config :aggregate, false, :short => 'a', &c.boolean
-      
-      # Initializes a new join with the specified configuration.
-      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 name.
-      def name
-        File.basename(self.class.to_s.underscore).to_sym
-      end
-      
-      # 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.
-      def options
-        opts = config.to_hash
-        opts.delete_if {|key, value| value == false }
-        opts
-      end
-      
-      # Returns a string like: "#<Join:object_id>"
-      def inspect
-        "#<Join:#{object_id}>"
-      end
-      
-      protected
-      
-      # 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
-      #
-      def enq(executable, *_results)
-        case
-        when aggregate
-          
-          case
-          when iterate, splat, stack
-            raise "iterate, splat, or stack and aggregate"
-          else collect(executable, _results)
-          end
-          
-        else
-          unpack(_results) do |_result|
-            case
-            when stack
-              executable.enq(*_result)            
-            else
-              executable._execute(*_result)
-            end
-          end
-        end
-      end
-      
-      # returns the aggregator for self
-      def aggregator # :nodoc:
-        @aggregator ||= {}
-      end
-      
-      # helper method to aggregate audited results
-      def collect(executable, inputs) # :nodoc:
-        queue = executable.app.queue
-        entry = aggregator[executable]
-        
-        queue.synchronize do
-          unless queue.has?(entry)
-            entry = aggregator[executable] = [executable, []]
-            queue.concat [entry]
-          end
-          entry[1].concat(inputs)
-        end
-      end
-      
-      # 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
-      
-      # 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
-end

data/lib/tap/support/joins.rb

@@ -1,12 +0,0 @@
-require 'tap/support/join'
-
-module Tap
-  module Support
-    
-    # A module of the standard Join classes supported by Tap.
-    module Joins
-      autoload(:SyncMerge, 'tap/support/joins/sync_merge')
-      autoload(:Switch, 'tap/support/joins/switch')  
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-module Tap
-  module Support
-    module Joins
-      
-      # 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(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(output, _result)
-              else
-                input.app.aggregator.store(_result)
-              end
-            end
-          end
-        end
-      end
-      
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-module Tap
-  module Support
-    module Joins
-      
-      # 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 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,171 +0,0 @@
-require 'tap/support/minimap'
-require 'tap/support/intern'
-
-module Tap
-  module Support
-    
-    # Stores an array of paths and makes them available for lookup by
-    # minipath.  Manifests may be bound to a Tap::Env, allowing searches
-    # across a full environment (including nested environments).
-    #
-    # Manifest has a number of hooks used by subclasses like 
-    # ConstantManifest to lazily add entries as needed.
-    class Manifest
-      class << self
-        
-        # Interns a new manifest, overriding the minikey
-        # method with the block (the minikey method converts
-        # entries to the path used during minimap and 
-        # minimatch lookup, see Minimap).
-        def intern(*args, &block)
-          instance = new(*args)
-          if block_given?
-            instance.extend Support::Intern(:minikey)
-            instance.minikey_block = block
-          end
-          instance
-        end
-      end
-      
-      include Enumerable
-      include Minimap
-      
-      # Matches a compound manifest search key.  After the match,
-      # if the key is compound then:
-      #
-      #  $1:: env_key
-      #  $4:: key
-      #
-      # If the key is not compound, $4 is nil and $1 is the key.
-      SEARCH_REGEXP = /^(([A-z]:)?.*?)(:(.*))?$/
-      
-      # An array entries in self.
-      attr_reader :entries
-      
-      # The bound Tap::Env, or nil.
-      attr_reader :env
-      
-      # The reader on Tap::Env accessing manifests of the
-      # same type as self. reader is set during bind.
-      attr_reader :reader
-      
-      # Initializes a new, unbound Manifest.
-      def initialize(entries=[])
-        @entries = entries
-        @env = nil
-        @reader = nil
-      end
-      
-      # Binds self to an env and reader.  The manifests returned by env.reader
-      # will be used during traversal methods like search.  Raises an error if
-      # env does not respond to reader; returns self.
-      def bind(env, reader)
-        if env == nil
-          raise ArgumentError, "env may not be nil" 
-        end
-        
-        unless env.respond_to?(reader)
-          raise ArgumentError, "env does not respond to #{reader}"
-        end
-        
-        @env = env
-        @reader = reader
-        self
-      end
-      
-      # Unbinds self from env.  Returns self.
-      def unbind
-        @env = nil
-        @reader = nil
-        self
-      end
-      
-      # True if the env and reader have been set.
-      def bound?
-        @env != nil && @reader != nil
-      end
-      
-      # A hook for dynamically building entries.  By default build simply
-      # returns self
-      def build
-        self
-      end
-      
-      # A hook to flag when self is built.  By default built? returns true.
-      def built?
-        true
-      end
-      
-      # A hook to reset a build.  By default reset simply returns self.
-      def reset
-        self
-      end
-      
-      # True if entries are empty.
-      def empty?
-        entries.empty?
-      end
-      
-      # Iterates over each entry entry in self.
-      def each
-        entries.each {|entry| yield(entry) }
-      end
-      
-      # Alias for Minimap#minimatch.
-      def [](key)
-        minimatch(key)
-      end
-      
-      # Search across env.each for the first entry minimatching key.
-      # A single env can be specified by using a compound key like
-      # 'env_key:key'.  Returns nil if no matching entry is found.
-      #
-      # Search raises an error unless bound?
-      def search(key)
-        raise "cannot search unless bound" unless bound?
-        
-        key =~ SEARCH_REGEXP
-        envs = if $4 != nil
-          # compound key, match for env
-          key = $4
-          [env.minimatch($1)].compact
-        else
-          # not a compound key, search all
-          # envs by iterating env itself
-          env
-        end
-        
-        # traverse envs looking for the first
-        # manifest entry matching key
-        envs.each do |env|
-          if result = env.send(reader).minimatch(key)
-            return result
-          end
-        end
-        
-        nil
-      end
-      
-      def inspect(traverse=true)
-        if traverse && bound?
-          lines = []
-          env.each do |env|
-            manifest = env.send(reader).build
-            next if manifest.empty?
-            
-            lines << "== #{env.root.root}"
-            manifest.minimap.each do |mini, value| 
-              lines << "  #{mini}: #{value.inspect}"
-            end
-          end
-          return lines.join("\n")
-        end
-        
-        lines = minimap.collect do |mini, value| 
-          "  #{mini}: #{value.inspect}"
-        end
-        "#{self.class}:#{object_id} (#{bound? ? env.root.root : ''})\n#{lines.join("\n")}"
-      end
-    end
-  end
-end

data/lib/tap/support/minimap.rb

@@ -1,90 +0,0 @@
-require 'tap/root'
-
-module Tap
-  module Support
-    
-    # Minimap adds minimization and search methods to an array of paths (see 
-    # Tap::Root.minimize and Tap::Root.minimal_match?).
-    # 
-    #   paths = %w{
-    #     path/to/file-0.1.0.txt 
-    #     path/to/file-0.2.0.txt
-    #     path/to/another_file.txt
-    #   }
-    #   paths.extend Minimap
-    #
-    #   paths.minimatch('file')             # => 'path/to/file-0.1.0.txt'
-    #   paths.minimatch('file-0.2.0')       # => 'path/to/file-0.2.0.txt'
-    #   paths.minimatch('another_file')     # => 'path/to/another_file.txt'
-    #
-    # More generally, Minimap may extend any object responding to each. 
-    # Override the minikey method to convert objects into paths.
-    #
-    #   class ConstantMap < Array
-    #     include Minimap
-    #
-    #     def minikey(const)
-    #       const.underscore
-    #     end
-    #   end 
-    #
-    #   constants = ConstantMap[Tap::Support::Minimap Tap::Root]
-    #   constants.minimatch('root')         # => Tap::Root
-    #   constants.minimatch('minimap')      # => Tap::Support::Minimap
-    #
-    module Minimap
-
-      # Provides a minimized map of the entries using keys provided minikey.
-      #
-      #   paths = %w{
-      #     path/to/file-0.1.0.txt 
-      #     path/to/file-0.2.0.txt
-      #     path/to/another_file.txt
-      #   }.extend Minimap
-      #
-      #   paths.minimap
-      #   # => [
-      #   # ['file-0.1.0',  'path/to/file-0.1.0.txt'],
-      #   # ['file-0.2.0',  'path/to/file-0.2.0.txt'],
-      #   # ['another_file','path/to/another_file.txt']]
-      #
-      def minimap
-        hash = {}
-        map = []
-        each {|entry| map << (hash[minikey(entry)] = [entry]) }
-        Tap::Root.minimize(hash.keys) do |key, mini_key|
-          hash[key].unshift mini_key
-        end
-        
-        map
-      end
-      
-      # Returns the first entry whose minikey mini-matches the input, or nil if
-      # no such entry exists.
-      #
-      #   paths = %w{
-      #     path/to/file-0.1.0.txt 
-      #     path/to/file-0.2.0.txt
-      #     path/to/another_file.txt
-      #   }.extend Minimap
-      #
-      #   paths.minimatch('file-0.2.0')       # => 'path/to/file-0.2.0.txt'
-      #   paths.minimatch('file-0.3.0')       # => nil
-      #
-      def minimatch(key)
-        each do |entry| 
-          return entry if Tap::Root.minimal_match?(minikey(entry), key)
-        end
-        nil
-      end
-      
-      protected
-      
-      # A hook to convert a non-path entry into a path for minimap and
-      # minimatch.  Returns the entry by default.
-      def minikey(entry)
-        entry
-      end
-    end
-  end
-end