bahuvrihi-tap 0.10.0 → 0.10.1

data/bin/tap

@@ -10,37 +10,14 @@
 #   tap command --help                   # prints help for 'command'
 #
 
-tap_root_dir  = File.dirname(__FILE__) + "/.."
-require "#{tap_root_dir}/lib/tap.rb"
+require "#{File.dirname(__FILE__)}/../lib/tap.rb"
+require 'tap/exe'
 
 # setup the environment
 begin
   
   $DEBUG = true if ARGV.delete('-d-')
-  before = nil
-  after = nil
-  aliases = nil
-
-  app = Tap::App.instance
-  env = Tap::Env.instantiate(app, Tap::Env.load_config(Tap::Env::GLOBAL_CONFIG_FILE), app.logger) do |unhandled_configs|
-    before = unhandled_configs.delete(:before)
-    after = unhandled_configs.delete(:after)
-    
-    aliases = unhandled_configs.delete(:alias)
-    Tap::Support::Validation.validate(aliases, [Hash]) if aliases
-
-    unless unhandled_configs.empty?
-      local.log(:warn, "ignoring non-env configs: #{unhandled_configs.keys.join(',')}", Logger::DEBUG)
-    end
-  end
-  
-  # add all gems if no gems are specified (Note this is VERY SLOW ~ 1/3 the overhead for tap)
-  if !File.exists?(Tap::Env::DEFAULT_CONFIG_FILE)
-    env.gems = Tap::Env.known_gems(true)
-  end
-  
-  tap = Tap::Env.instance_for(tap_root_dir)
-  env.push(tap)
+  env = Tap::Exe.instantiate
 
 rescue(Tap::Env::ConfigError)
   # catch errors and exit gracefully
@@ -55,7 +32,7 @@ end
 
 at_exit do
   begin
-    eval(after) if after != nil
+    eval(env.after) if env.after != nil
   rescue(Exception)
     puts "Error in after script."
     env.handle_error($!)
@@ -68,7 +45,7 @@ end
 #
 
 begin
-  eval(before) if before != nil
+  eval(env.before) if env.before != nil
 rescue(Exception)
   puts "Error in before script."
   env.handle_error($!)
@@ -81,15 +58,7 @@ end
 
 begin
   env.activate
-
-  command = ARGV.shift
-  if aliases && aliases.has_key?(command)
-    aliases[command].reverse_each {|arg| ARGV.unshift(arg)}
-    command = ARGV.shift
-  end
-
-  case command  
-  when nil, '--help'
+  env.run do
     # give some help
     require 'tap/support/command_line'
     
@@ -98,14 +67,7 @@ begin
     puts "available commands:"
     puts env.summarize(:commands)
     puts
-    puts "version #{Tap::VERSION} -- #{Tap::WEBSITE}" 
-  else
-    if path = env.search(:commands, command)
-      load path # run the command, if it exists
-    else
-      puts "Unknown command: '#{command}'"
-      puts "Type 'tap help' for usage information."
-    end
+    puts "version #{Tap::VERSION} -- #{Tap::WEBSITE}"
   end
 rescue
   env.handle_error($!)

data/cmd/manifest.rb

@@ -0,0 +1,94 @@
+# tap manifest
+#
+# Prints information about each env.
+#
+
+options = {}
+OptionParser.new do |opts|
+  
+  opts.separator ""
+  opts.separator "options:"
+
+  opts.on("-h", "--help", "Show this message") do
+    opts.banner = cmdline.usage(__FILE__)
+    puts opts
+    exit
+  end
+  
+  opts.on("-e", "--envs_only", "Only list environments") do
+    options[:envs_only] = true
+  end
+  
+  opts.on("-r", "--require FILEPATH", "Require the specified file") do |value|
+    require value
+  end
+  
+end.parse!(ARGV)
+
+# Simply a method to collect and format paths for
+# the specified manifest.
+def collect_map(env, manifest)
+  width = 10
+  map = manifest.minimize.collect do |(key, path)|
+    path = case path
+    when Tap::Support::Constant then path.require_path
+    else path
+    end
+    
+    width = key.length if width < key.length
+    [key, env.root.relative_filepath(:root, path) || path]
+  end.collect do |args|
+    "%-#{width}s (%s)" % args
+  end
+  
+  map.unshift("") unless map.empty?
+  map
+end
+
+# Collect remaining args as 
+env = Tap::Env.instance
+envs_manifest = if ARGV.empty?
+  env.manifest(:envs, true).minimize
+else
+  ARGV.collect do |name| 
+    entry = env.find(:envs, name, false)
+    raise "could not find an env matching: #{name}" if entry == nil
+    entry
+  end
+end
+
+width = 10
+envs_manifest.each {|(env_name, e)| width = env_name.length if width < env_name.length}
+width += 2
+
+env.each do |current|
+  env_name, current = envs_manifest.find {|(env_name, e)| e == current }
+  next if env_name == nil
+  
+  puts '-' * 80 unless options[:envs_only]
+  puts "%-#{width}s (%s)" % [env_name + ':', current.root.root]
+  
+  next if options[:envs_only]
+  
+  manifest_keys = (Tap::Env.manifests.keys + current.manifests.keys).uniq 
+  manifest_keys.each do |name|
+    next if name == :envs
+    manifest = current.manifest(name, true)
+    next if manifest.empty?
+    
+    puts "  %-10s %s" % [name, collect_map(current, manifest).join("\n    ")]
+  end
+end
+
+if ARGV.empty?
+  puts '-' * 80
+  puts
+  env.recursive_each(0, nil) do |current, nesting_depth, last_env|
+    env_name, current = envs_manifest.find {|(env_name, e)| e == current }
+
+    leader = nesting_depth == 0 ? "" : '|   ' * (nesting_depth - 1) + (last_env == current ? "`- " : "|- ")
+    puts("#{leader}#{env_name}")
+    [nesting_depth + 1, current.envs[-1]]
+  end
+  puts
+end

data/cmd/run.rb

@@ -23,7 +23,7 @@ OptionParser.new do |opts|
     next if receiver == Tap::Root
     
     opts.on(*cmdline.configv(config)) do |value|
-      app.send(configuration.writer, value)
+      app.send(config.writer, value)
     end
   end
  

data/lib/tap.rb

@@ -1,5 +1,3 @@
-require 'rubygems'
-
 require 'yaml'                   # expensive to load
 require 'thread'
 
@@ -7,9 +5,6 @@ require 'thread'
 case RUBY_VERSION
 when /^1.9/
   $: << File.expand_path(File.dirname(__FILE__) + "/tap/patches/ruby19")
-  
-  # suppresses TDoc warnings
-  $DEBUG_RDOC ||= nil 
 end
 
 $:.unshift File.expand_path(File.dirname(__FILE__))

data/lib/tap/constants.rb

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

data/lib/tap/env.rb

@@ -1,7 +1,7 @@
-require 'tap/root'
+require 'tap/support/manifest'
 require 'tap/support/constant'
 require 'tap/support/summary'
-require 'tap/support/manifest'
+require 'tap/support/gems'
 
 module Tap
 
@@ -12,16 +12,13 @@ module Tap
     include Support::Configurable
     include Enumerable
     
-    @@instance = nil
-    @@instances = {}
-    @@manifests = {}
-
-    class << self  
+    class << self
+      
       # Returns the active instance of Env.
       def instance
         @@instance
       end
-
+      
       # A hash of (path, Env instance) pairs, generated by Env#instantiate.  Used
       # to prevent infinite loops of Env dependencies by assigning a single Env
       # to a given path.
@@ -29,6 +26,13 @@ module Tap
         @@instances
       end
       
+      # A hash of predefined manifest classes that can be initialized
+      # from an env.  These classes are instantiated by instances
+      # of Env, as needed.
+      def manifests
+        @@manifests
+      end
+      
       # Creates a new Env for the specified path and adds it to Env#instances, or 
       # returns the existing instance for the path.  Paths can point to an env config
       # file, or to a directory.  If a directory is provided, instantiate treats
@@ -45,7 +49,7 @@ module Tap
       # The Env is initialized using configurations read from the env config file using
       # load_config, and a Root initialized to the config file directory. An instance 
       # will be initialized regardless of whether the config file or directory exists.
-      def instantiate(path_or_root, default_config={}, logger=nil)
+      def instantiate(path_or_root, default_config={}, logger=nil, &block)
         path = path_or_root.kind_of?(Root) ? path_or_root.root : path_or_root
         path = pathify(path)
         
@@ -55,14 +59,17 @@ module Tap
           
           # note the assignment of env to instances MUST occur before
           # reconfigure to prevent infinite looping
-          (instances[path] = Env.new({}, root, logger)).reconfigure(config) do |unhandled_configs|
-            yield(unhandled_configs) if block_given?
-          end
+          (instances[path] = new({}, root, logger)).reconfigure(config, &block)
         rescue(Exception)
           raise Env::ConfigError.new($!, path)
         end
       end
       
+      def instance_for(path)
+        path = pathify(path)
+        instances.has_key?(path) ? instances[path] : instantiate(path)
+      end
+      
       def pathify(path)
         if File.directory?(path) || (!File.exists?(path) && File.extname(path) == "")
           path = File.join(path, DEFAULT_CONFIG_FILE) 
@@ -70,41 +77,60 @@ module Tap
         File.expand_path(path)
       end
       
-      def instance_for(path)
-        path = pathify(path)
-        instances.has_key?(path) ? instances[path] : instantiate(path)
-      end
-
-      # 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
-      
-      # Returns the gem name for all installed gems with a DEFAULT_CONFIG_FILE.
-      # If latest==true, then only the names for the most current gem specs
-      # will be returned.
-      def known_gems(latest=true)
-        index = latest ?
-          Gem.source_index.latest_specs :
-          Gem.source_index.gems.collect {|(name, spec)| spec }
+      def manifest(name, pattern, default_paths=[], &block) # :yields: search_path
+        manifest_class = Class.new(Support::Manifest)
+        manifest_class.send(:define_method, :entries_for, &block) if block_given?
+        manifest_class.send(:attr_reader, :env)
+        manifest_class.send(:define_method, :initialize) do |env|
+          @env = env
+          search_paths = default_paths.collect {|path| env.root[path] }
+          search_paths += env.root.glob(:root, pattern)
+          super search_paths.sort_by {|p| File.basename(p) }
+        end
         
-        index.select do |spec|
-          File.exists?(File.join(spec.full_gem_path, DEFAULT_CONFIG_FILE)) ||
-          File.exists?(File.join(spec.full_gem_path, DEFAULT_TASK_FILE))
-        end.sort
+        manifests[name] = manifest_class
+      end
+      
+      #--
+      # To manifest simply requires an glob_<name> method which
+      # yields each (key, path) pair for the manifested object in
+      # a predictable order. 
+      #
+      #--
+      # Alternate implementation would create the manifest for each individual
+      # env, then merge the manifests.  On the plus side, each env would then
+      # carry it's own slice of the manifest without having to recalculate.
+      # On the down side, the merging would have to occur in some separate
+      # method that cannot be defined here.
+      def path_manifest(name, paths_key, pattern, default_paths=[], &block) # :yields: search_path_root, search_path
+        manifest_class = Class.new(Support::Manifest)
+        manifest_class.send(:define_method, :entries_for, &block) if block_given?
+        manifest_class.send(:attr_reader, :env)
+        manifest_class.send(:define_method, :initialize) do |env|
+          @env = env
+          search_paths = default_paths.collect do |path| 
+            [env.root.root, env.root[path]]
+          end
+          
+          env.send(paths_key).each do |search_path_root|
+            env.root.glob(search_path_root, pattern).each do |search_path|
+              search_paths << [search_path_root, search_path]
+            end
+          end
+          
+          super search_paths.sort_by {|pr, p| File.basename(p) }
+        end
+        manifests[name] = manifest_class
+      end
+      
+      # Returns the gemspecs for all installed gems with a DEFAULT_TASK_FILE
+      # or DEFAULT_CONFIG_FILE. If latest==true, then only the specs for the 
+      # most current gems will be returned.
+      def gemspecs(latest=true)
+        Support::Gems.select_gems(latest) do |spec|
+          File.exists?(File.join(spec.full_gem_path, DEFAULT_TASK_FILE)) ||
+          File.exists?(File.join(spec.full_gem_path, DEFAULT_CONFIG_FILE))
+        end
       end
       
       protected
@@ -137,46 +163,21 @@ module Tap
           instance_variable_set(instance_variable, [*input].compact.collect {|path| root[path]}.uniq)
         end
       end
-      
-      #--
-      # To manifest simply requires an glob_<name> method which
-      # yields each (key, path) pair for the manifested object in
-      # a predictable order. 
-      #
-      #--
-      # Alternate implementation would create the manifest for each individual
-      # env, then merge the manifests.  On the plus side, each env would then
-      # carry it's own slice of the manifest without having to recalculate.
-      # On the down side, the merging would have to occur in some separate
-      # method that cannot be defined here.
-      def manifest(name, paths_key, pattern, &block)
-        return manifest(name, paths_key, pattern) do |context, path|
-           [[path.chomp(File.extname(path)), path]]
-        end unless block_given?
-        
-        glob_method = Support::Manifest.glob_method(name)
-        module_eval %Q{
-          def #{glob_method}
-            paths = []
-            self.#{paths_key}.each do |manifest_path|
-              root.glob(manifest_path, "#{pattern}").each do |path|
-                next if File.directory?(path)
-                paths << [manifest_path, path]
-              end
-            end
-            paths.sort_by {|mp, p| File.basename(p)}
-          end
-        }
-
-        map_method = Support::Manifest.map_method(name)
-        define_method(map_method, &block)
-        
-        protected glob_method, map_method
+    end
+    
+    class Manifest < Support::Manifest
+      def initialize(env)
+        super([])
+        @entries = env.collect {|e| [e.root.root, e] }
       end
     end
     
+    @@instance = nil
+    @@instances = {}
+    @@manifests = {:envs => Manifest}
+
     # The global config file path
-    GLOBAL_CONFIG_FILE = File.join(Gem.user_home, ".tap.yml")
+    GLOBAL_CONFIG_FILE = File.join(Support::Gems.user_home, ".tap.yml")
     
     # The default config file path
     DEFAULT_CONFIG_FILE = "tap.yml"
@@ -204,7 +205,7 @@ module Tap
     config_attr :gems, [] do |input|
       check_configurable
       @gems = [*input].compact.collect do |gem_name| 
-        spec = Env.gemspec(gem_name)
+        spec = Support::Gems.gemspec(gem_name)
         
         case spec
         when nil then log(:warn, "unknown gem: #{gem_name}", Logger::WARN)
@@ -224,10 +225,8 @@ module Tap
       end.uniq
       reset_envs
     end
- 
-    # Designate load paths.  If use_dependencies == true, then
-    # load_paths will be used for automatic loading of modules
-    # through the active_support Dependencies module.
+    
+    # Designate load paths.
     path_config :load_paths, ["lib"]
     
     # Designate paths for discovering and executing commands. 
@@ -236,12 +235,12 @@ module Tap
     # Designate paths for discovering generators.  
     path_config :generator_paths, ["lib"]
     
-    manifest(:tasks, :load_paths, "**/*.rb") do |load_path, path|
-      next unless document = Support::Lazydoc.scan_doc(path, 'manifest')
+    path_manifest(:tasks, :load_paths, "**/*.rb", [DEFAULT_TASK_FILE]) do |load_path, path|
+      next unless File.file?(path) && document = Support::Lazydoc.scan_doc(path, 'manifest')
       
       document.const_names.collect do |const_name|
         if const_name.empty?
-          key = root.relative_filepath(load_path, path).chomp('.rb')
+          key = env.root.relative_filepath(load_path, path).chomp('.rb')
           [key, Support::Constant.new(key.camelize, path)]
         else
           [const_name.underscore, Support::Constant.new(const_name, path)]
@@ -249,16 +248,18 @@ module Tap
       end
     end
     
-    manifest(:commands, :command_paths, "**/*.rb") 
+    path_manifest(:commands, :command_paths, "**/*.rb") do |command_path, path|
+      File.file?(path) ? [[path, path]] : nil
+    end
     
-    manifest(:generators, :generator_paths, '**/*_generator.rb') do |load_path, path|
+    path_manifest(:generators, :generator_paths, '**/*_generator.rb') do |generator_path, path|
       dirname = File.dirname(path)
-      next unless "#{File.basename(dirname)}_generator.rb" == File.basename(path)
+      next unless File.file?(path) && "#{File.basename(dirname)}_generator.rb" == File.basename(path)
       
       next unless document = Support::Lazydoc.scan_doc(path, 'generator')
       document.const_names.collect do |const_name|
         if const_name.empty?
-          key = root.relative_filepath(load_path, dirname)
+          key = env.root.relative_filepath(generator_path, dirname)
           [key, Support::Constant.new((key + '_generator').camelize, path)]
         else
           [const_name.underscore, Support::Constant.new(const_name, path)]
@@ -304,7 +305,7 @@ module Tap
       unless env == self || envs[0] == env
         self.envs = envs.dup.unshift(env)
       end
-      envs
+      self
     end
     
     # Pushes env onto envs, removing duplicates.  
@@ -314,7 +315,7 @@ module Tap
         envs = self.envs.reject {|e| e == env }
         self.envs = envs.push(env)
       end
-      envs
+      self
     end
     
     # Passes each nested env to the block in order, starting with self.
@@ -327,18 +328,40 @@ module Tap
       envs(true).reverse_each {|e| yield(e) }
     end
     
+    # Visits each nested env in order, starting with self, and passing
+    # to the block the env and any arguments generated by the parent of 
+    # the env.  The initial arguments are set when recursive_each is 
+    # first called; subsequent arguements are the return values of the 
+    # block.
+    #
+    #   e0, e1, e2, e3, e4 = ('a'..'e').collect {|name| Tap::Env.new(:name => name) }
+    # 
+    #   e0.push(e1).push(e2)
+    #   e1.push(e3).push(e4)
+    # 
+    #   lines = []
+    #   e0.recursive_each(0) do |env, nesting_depth|
+    #     lines << "\n#{'..' * nesting_depth}#{env.config[:name]} (#{nesting_depth})"
+    #     nesting_depth + 1
+    #   end
+    #
+    #   lines.join
+    #   # => %Q{
+    #   # a (0)
+    #   # ..b (1)
+    #   # ....d (2)
+    #   # ....e (2)
+    #   # ..c (1)}
+    #
+    def recursive_each(*args, &block) # :yields: env, *parent_args
+      each_nested_env(self, [], args, &block)
+    end
+    
     # Returns the total number of unique envs nested in self (including self).
     def count
       envs(true).length
     end
     
-    # Returns a list of arrays that receive load_paths on activate,
-    # by default [$LOAD_PATH]. If use_dependencies == true, then
-    # Dependencies.load_paths will also be included.
-    def load_path_targets
-      [$LOAD_PATH]
-    end
-    
     # Processes and resets the input configurations for both root
     # and self. Reconfiguration consists of the following steps:
     #
@@ -412,7 +435,7 @@ module Tap
       return false if active?
       
       @active = true
-      @@instance = self unless @@instance
+      @@instance = self if @@instance == nil
       
       # freeze array configs like load_paths
       config.each_pair do |key, value|
@@ -426,15 +449,12 @@ module Tap
         env.activate
       end
 
-      # add load paths to load_path_targets
-      load_path_targets.each do |target|
-        load_paths.reverse_each do |path|
-          target.unshift(path)
-        end
-    
-        target.uniq!
+      # add load paths
+      load_paths.reverse_each do |path|
+        $LOAD_PATH.unshift(path)
       end
     
+      $LOAD_PATH.uniq!
       true
     end
     
@@ -446,13 +466,11 @@ module Tap
     def deactivate
       return false unless active?
       
-      # remove load paths from load_path_targets
-      load_path_targets.each do |target|
-        load_paths.each do |path|
-          target.delete(path)
-        end
+      # remove load paths
+      load_paths.each do |path|
+        $LOAD_PATH.delete(path)
       end
-      
+
       # unfreeze array configs by duplicating
       self.config.class_config.each_pair do |key, value|
         value = send(key)
@@ -478,57 +496,76 @@ module Tap
       @active
     end
     
-    # Cycles through all items yielded by the iterate_<name> method and
-    # adds each to the manifests[name] hash.  Freezes the hash when complete.
-    # Simply returns the manifests[name] hash if frozen.
-    def manifest(name) 
-      manifest = manifests[name] ||= Support::Manifest.new(name, self)
-
-      manifest.entries.each do |key, path| 
-        yield(key, path) 
-      end if block_given?
-            
-      manifest.each_path do |context, path|
-        next unless keys = send(manifest.map_method, context, path)
-        
-        keys.each {|entry| manifest.store(entry) }
-        keys.each {|key, value| yield(key, value) } if block_given?
-      end unless manifest.complete?
-
+    # Returns the manifest in manifests by the specified name. Yields
+    # each entry in the manifest to the block, if given, or simply
+    # builds and returns the manifest. 
+    #
+    # If the specified manifest does not exists, the manifest class
+    # in self.class.manifests will be instatiated with self to make
+    # the manifest.  Raises an error if no manifest could be found
+    # or instantiated.
+    def manifest(name, build=false) 
+      manifest = manifests[name] ||= case 
+      when manifests_class = self.class.manifests[name]
+        manifests_class.new(self)
+      else 
+        raise "unknown manifest: #{name}"
+      end
+      
+      manifest.build if build  
       manifest
     end
     
-    def find(name, pattern)
-      manifest(name) do |key, path|
-        return path if Root.minimal_match?(key, pattern)
+    # Returns the first value in the specified manifest where the key
+    # mini-matches the input pattern.  See Tap::Root.minimal_match? 
+    # for details on mini-matching.
+    def find(name, pattern, value_only=true)
+      manifest(name).each do |key, value|
+        return(value_only ? value : [key, value]) if Root.minimal_match?(key, pattern)
       end
       nil
     end
     
-    def search(name, pattern)
-      return find(name, pattern) if name == :envs
+    # Like find, but searches across all envs for the matching value.
+    # An env pattern can be provided in pattern, to select a single
+    # env to search.
+    #
+    # The :envs manifest cannot be searched; use find instead.
+    def search(name, pattern, value_only=true)
+      if name == :envs
+        raise ArgumentError, "cannot search the :envs manifest; use find instead" 
+      end
       
       envs = case pattern
       when /^(.*):([^:]+)$/
         env_pattern = $1
         pattern = $2
-        find(:envs, env_pattern) or raise(ArgumentError, "could not find env: #{env_pattern}")
+        find(:envs, env_pattern)
       else manifest(:envs).values
       end
       
       envs.each do |env|
-        if result = env.find(name, pattern)
+        if result = env.find(name, pattern, value_only)
           return result
         end
-      end
+      end if envs
       
       nil
     end
     
+    def constantize(name, *patterns)
+      patterns.collect do |pattern| 
+        case const = search(name, pattern)
+        when Support::Constant then const.constantize
+        else raise "could not constantize: #{pattern} (#{name})" 
+        end
+      end
+    end
+    
     def summary(name)
       summary = Support::Summary.new
-      manifest(:envs).mini_map.each do |(key, env)|
-       summary.add(key, env, env.manifest(name).mini_map)
+      manifest(:envs, true).minimize.each do |(key, env)|
+       summary.add(key, env, env.manifest(name, true).minimize)
       end
       summary
     end
@@ -546,51 +583,9 @@ module Tap
     def to_s
       inspect(true)
     end
-
-    #--
-    # Under construction
-    #++
-    
-    def handle_error(err)
-      case
-      when $DEBUG
-        puts err.message
-        puts
-        puts err.backtrace
-      else puts err.message
-      end
-    end
     
     protected
     
-    # Iterates over each nested env, yielding the root path and env.
-    # This is the manifest method for envs.
-    def manifest_glob_envs
-      collect {|env| [env.root.root, env] }.sort_by {|root, env| File.basename(root) }
-    end
-    
-    def manifest_map(context, path)
-      [[context, path]]
-    end
-    
-    alias default_manifest_glob_tasks manifest_glob_tasks
-    
-    def manifest_glob_tasks
-      paths = default_manifest_glob_tasks
-      
-      # very odd behaviors --
-      # * OS X is case-insensitive, apparently.  Tapfile.rb and tapfile.rb are the same.
-      # * require 'tapfile' does not work
-      # * require 'tapfile.rb' works
-      # * load 'tapfile' works
-      #
-      root.glob(:root, DEFAULT_TASK_FILE).each do |path|
-        next if File.directory?(path)
-        paths.unshift [root.root, path]
-      end
-      paths
-    end
-    
     # Raises an error if self is already active (and hence, configurations
     # should not be modified)
     def check_configurable
@@ -619,7 +614,20 @@ module Tap
       
       target
     end
-
+    
+    private
+    
+    def each_nested_env(env, visited, args, &block)
+      return if visited.include?(env)
+      
+      visited << env
+      next_args = yield(env, *args)
+      next_args = [] if next_args == nil
+      env.envs.each do |nested_env|
+        each_nested_env(nested_env, visited, next_args, &block)
+      end
+    end
+    
     # Raised when there is a Env-level configuration error.
     class ConfigError < StandardError
       attr_reader :original_error, :env_path