rubycut-babushka 0.10.8 → 0.15.6.1

data/lib/babushka/base.rb

@@ -1,7 +1,32 @@
 module Babushka
+
+  # +host+ is an instance of Babushka::SystemProfile for the system the command
+  # was invoked on.
+  # If the current system isn't supported, SystemProfile.for_host will return
+  # +nil+, and Base.run will fail early. If the system is known but the
+  # flavour isn't (e.g. an unknown Linux variant), a generic SystemProfile
+  # will be used, which should work for most operations but will fail on deps
+  # that attempt to use the package manager, etc.
+  def host
+    @host ||= Babushka::SystemDetector.profile_for_host
+  end
+  module_function :host
+
+  def ruby
+    @ruby ||= Babushka::CurrentRuby.new
+  end
+  module_function :ruby
+
   class Base
   class << self
 
+    # The time at which babushka was loaded. This is used in LogHelpers to
+    # print profiling information via the '--profile' commandline option.
+    @@start_time = Time.now
+    def start_time
+      @@start_time
+    end
+
     # +task+ represents the overall job that is being run, and the parts that
     # are external to running the corresponding dep tree itself - logging, and
     # var loading and saving in particular.
@@ -17,15 +42,8 @@ module Babushka
       @cmdline ||= Cmdline::Parser.for(ARGV)
     end
 
-    # +host+ is an instance of Babushka::SystemProfile for the system the command
-    # was invoked on.
-    # If the current system isn't supported, SystemProfile.for_host will return
-    # +nil+, and Base.run will fail early. If the system is known but the
-    # flavour isn't (e.g. an unknown Linux variant), a generic SystemProfile
-    # will be used, which should work for most operations but will fail on deps
-    # that attempt to use the package manager, etc.
     def host
-      @host ||= Babushka::SystemProfile.for_host
+      Babushka::LogHelpers.removed! :method_name => 'Babushka::Base.host', :instead => "Babushka.host"
     end
 
     # +sources+ is an instance of Babushka::SourcePool, contains all the
@@ -70,6 +88,17 @@ module Babushka
       end
     end
 
+    def runtime_info
+      @runtime_info ||= "babushka@#{ref} | #{ShellHelpers.which('ruby')}@#{RUBY_VERSION}-p#{RUBY_PATCHLEVEL}"
+    end
+
+    def ref
+      @ref ||= begin
+        repo = GitRepo.new(Path.path)
+        repo.current_head if repo.exists?
+      end
+    end
+
     def program_name
       @program_name ||= ENV['PATH'].split(':').include?(File.dirname($0)) ? File.basename($0) : $0
     end

data/lib/babushka/bug_reporter.rb

@@ -39,16 +39,16 @@ module Babushka
       if response.is_a? Net::HTTPSuccess
         gist_id = response.body.scan(/<repo>(\d+)<\/repo>/).flatten.first
         if gist_id.nil?
-          log "Done, but the report's URL couldn't be parsed. Here's some info:"
-          log response.body
+          log_stderr "Done, but the report's URL couldn't be parsed. Here's some info:"
+          log_stderr response.body
         else
           log "You can view the report at http://gist.github.com/#{gist_id} - thanks :)"
         end
       else
-        log "Deary me, the bug report couldn't be submitted! Would you mind emailing these two files:"
-        log '  ' + Base.task.var_path_for(dep)
-        log '  ' + Base.task.log_path_for(dep)
-        log "to ben@hoskings.net? Thanks."
+        log_stderr "Deary me, the bug report couldn't be submitted! Would you mind emailing these two files:"
+        log_stderr '  ' + Base.task.var_path_for(dep)
+        log_stderr '  ' + Base.task.log_path_for(dep)
+        log_stderr "to ben@hoskings.net? Thanks."
       end
     end
   end

data/lib/babushka/cmdline.rb

@@ -1,13 +1,14 @@
 # coding: utf-8
 
 module Babushka
-  module Cmdline
+  class Cmdline
     extend LogHelpers
 
     handle('global', "Options that are valid for any handler") {
       opt '-v', '--version',     "Print the current version"
       opt '-h', '--help',        "Show this information"
       opt '-d', '--debug',       "Show more verbose logging, and realtime shell command output"
+      opt '-s', '--silent',      "Only log errors, running silently on success"
       opt       '--[no-]color',
                 '--[no-]colour', "Disable color in the output"
     }
@@ -19,13 +20,13 @@ module Babushka
         Helpers.print_handlers
         Helpers.print_notes
       elsif (handler = Handler.for(cmd.argv.first)).nil?
-        Helpers.log "#{cmd.argv.first.capitalize}? I have honestly never heard of that."
+        log "#{cmd.argv.first.capitalize}? I have honestly never heard of that."
       else
-        Helpers.log "\n#{handler.name} - #{handler.description}"
+        log "\n#{handler.name} - #{handler.description}"
         cmd.parse(&handler.opt_definer)
         cmd.print_usage
       end
-      Helpers.log "\n"
+      log "\n"
       true
     }
 
@@ -45,17 +46,15 @@ module Babushka
     handle('meet', 'The main one: run a dep and all its dependencies.') {
       opt '-n', '--dry-run',      "Discover the curent state without making any changes"
       opt '-y', '--defaults',     "Assume the default value for all vars without prompting, where possible"
+      opt '-u', '--update',       "Update referenced sources before loading deps from them"
       opt       '--show-args',    "Show the arguments being passed between deps as they're run"
-      opt       '--track-blocks', "Track deps' blocks in TextMate as they're run"
+      opt       '--profile',      "Print a per-line timestamp to the debug log."
     }.run {|cmd|
-      # TODO: spec var parsing
       dep_names, vars = cmd.argv.partition {|arg| arg['='].nil? }
       if !(bad_var = vars.detect {|var| var[/^\w+=/].nil? }).nil?
         fail_with "'#{bad_var}' looks like a var but it doesn't make sense."
       elsif dep_names.empty?
         fail_with "Nothing to do."
-      elsif cmd.opts[:track_blocks] && !which('mate')
-        fail_with "The --track-blocks option requires TextMate, and the `mate` helper.\nOn a Mac, you can install them like so:\n  babushka benhoskings:textmate"
       else
         Base.task.process dep_names, vars.map {|i|
           i.split('=', 2)
@@ -117,9 +116,11 @@ module Babushka
       elsif dep.load_path.nil?
         fail_with "Can't edit '#{dep.name}, since it wasn't loaded from a file."
       else
-        file, line = dep.context.file_and_line
-        editor_var = ENV['BABUSHKA_EDITOR'] || ENV['VISUAL'] || ENV['EDITOR'] || which('mate') || which('vim') || which('vi')
+        file, line = dep.context.source_location
+        editor_var = ENV['BABUSHKA_EDITOR'] || ENV['VISUAL'] || ENV['EDITOR'] || which('subl') || which('mate') || which('vim') || which('vi')
         case editor_var
+        when /^subl/
+          exec "subl -n '#{file}':#{line}"
         when /^mate/
           exec "mate -l#{line} '#{file}'"
         when /^vim?/, /^nano/, /^pico/, /^emacs/

data/lib/babushka/cmdline/handler.rb

@@ -1,12 +1,16 @@
 require 'abbrev'
 
 module Babushka
-  module Cmdline
+  class Cmdline
 
-    def handle name, description, &blk
+    def self.handle name, description, &blk
       Handler.add name, description, blk
     end
-    module_function :handle
+
+    def self.fail_with message
+      log message
+      exit 1
+    end
 
     class Handler
       def self.add name, description, opt_definer

data/lib/babushka/cmdline/helpers.rb

@@ -1,27 +1,19 @@
 # coding: utf-8
 
 module Babushka
-  module Cmdline
-    module_function
-
-    def fail_with message
-      log message if message.is_a? String
-      exit 1
-    end
-
-    module Helpers
+  class Cmdline
+    class Helpers
       extend LogHelpers
-      module_function
 
-      def print_version opts = {}
+      def self.print_version opts = {}
         if opts[:full]
-          log "Babushka v#{VERSION}, (c) 2011 Ben Hoskings <ben@hoskings.net>"
+          log "Babushka v#{VERSION} (#{Base.ref}), (c) 2012 Ben Hoskings <ben@hoskings.net>"
         else
-          log VERSION
+          log "#{VERSION} (#{Base.ref})"
         end
       end
 
-      def print_usage
+      def self.print_usage
         log "\nThe gist:"
         log "  #{Base.program_name} <command> [options]"
         log "\nAlso:"
@@ -30,14 +22,14 @@ module Babushka
         log "  #{Base.program_name} babushka        # Update babushka itself (what babushka.me/up does)"
       end
 
-      def print_handlers
+      def self.print_handlers
         log "\nCommands:"
         Handler.all.each {|handler|
           log "  #{handler.name.ljust(10)} #{handler.description}"
         }
       end
 
-      def print_examples
+      def self.print_examples
         log "\nExamples:"
         log "  # Inspect the 'system' dep (and all its sub-deps) without touching the system.".colorize('grey')
         log "  #{Base.program_name} system --dry-run"
@@ -50,12 +42,12 @@ module Babushka
         log "  #{Base.program_name} 'user setup' --debug"
       end
 
-      def print_notes
+      def self.print_notes
         log "\nCommands can be abbrev'ed, as long as they remain unique."
         log "  e.g. '#{Base.program_name} l' is short for '#{Base.program_name} list'."
       end
 
-      def search_results_for q
+      def self.search_results_for q
         YAML.load(search_webservice_for(q).body).sort_by {|i|
           -i[:runs_this_week]
         }.map {|i|
@@ -69,7 +61,7 @@ module Babushka
         }
       end
 
-      def print_search_results search_term, results
+      def self.print_search_results search_term, results
         log "The webservice knows about #{results.length} dep#{'s' unless results.length == 1} that match#{'es' if results.length == 1} '#{search_term}':"
         log ""
         Logging.log_table(
@@ -85,17 +77,17 @@ module Babushka
         end
       end
 
-      def github_autosource_regex
-        /^git\:\/\/github\.com\/(.*)\/babushka-deps(\.git)?/
+      def self.github_autosource_regex
+        /^\w+\:\/\/github\.com\/(.*)\/babushka-deps(\.git)?/
       end
 
-      def search_webservice_for q
+      def self.search_webservice_for q
         Net::HTTP.start('babushka.me') {|http|
           http.get URI.escape("/deps/search.yaml/#{q}")
         }
       end
 
-      def generate_list_for to_list, filter_str
+      def self.generate_list_for to_list, filter_str
         context = to_list == :deps ? Base.program_name : ':template =>'
         match_str = filter_str.try(:downcase)
         Base.sources.all_present.each {|source|

data/lib/babushka/cmdline/parser.rb

@@ -1,7 +1,7 @@
 require 'optparse'
 
 module Babushka
-  module Cmdline
+  class Cmdline
     class Parser
       include LogHelpers
 

data/lib/babushka/core_patches/object.rb

@@ -11,7 +11,7 @@ class Object
   # neatly working with an object in some way before returning it:
   #   def valmorphanize
   #     process.tap {|result|
-  #       log "Oops!" unless result
+  #       log_error "Oops!" unless result
   #     }
   #   end
   def tap &block

data/lib/babushka/core_patches/string.rb

@@ -1,14 +1,15 @@
 class String
-  # Return a Dep::Requirement that specifies the dep that should later be
+  # Return a DepRequirement that specifies the dep that should later be
   # called, and the arguments that should be passed. This allows requiring
   # deps with a less noisy syntax, and the lookup is lazy (it happens at
-  # the point the dep is invoked, from its parent dep in Dep#process_deps).
+  # the point the dep is invoked, from its parent dep in
+  # Dep#process_requirements).
   #
   #   dep 'user has a password', :username do
   #     requires 'user exists'.with(username)
   #   end
   def with *args
-    Babushka::Dep::Requirement.new(self, args)
+    Babushka::DepRequirement.new(self, args)
   end
 
   # Returns true iff +other+ appears exactly at the start of +self+.
@@ -84,6 +85,10 @@ class String
     Babushka::VersionStr.new self
   end
 
+  def colorized?
+    self[/\e\[\d/]
+  end
+
   # Return a new string with the contents of this string surrounded in escape
   # sequences such that it will render as described in +description+.
   # Some examples:

data/lib/babushka/current_ruby.rb

@@ -0,0 +1,44 @@
+module Babushka
+  class CurrentRuby
+
+    def path
+      @path ||= Babushka::ShellHelpers.which('ruby').p
+    end
+
+    def rbenv?
+      path.to_s[%r{\brbenv/}]
+    end
+
+    def rvm?
+      path.to_s[%r{\brvm/}]
+    end
+
+    def bin_dir
+      # The directory in which the binaries from gems are found. This is
+      # sometimes different to where `gem` itself is running from.
+      gem_env.val_for('EXECUTABLE DIRECTORY').p
+    end
+
+    def gem_dir
+      gem_env.val_for('INSTALLATION DIRECTORY') / 'gems'
+    end
+
+    def gemspec_dir
+      gem_env.val_for('INSTALLATION DIRECTORY') / 'specifications'
+    end
+
+    def version
+      @_version ||= Babushka::ShellHelpers.shell('ruby --version').scan(/^ruby (\S+)/).flatten.first.to_version
+    end
+
+    def gem_version
+      gem_env.val_for('RUBYGEMS VERSION').to_version
+    end
+
+    private
+
+    def gem_env
+      @_gem_env ||= Babushka::ShellHelpers.shell('gem env')
+    end
+  end
+end

data/lib/babushka/dep.rb

@@ -13,31 +13,19 @@ module Babushka
   class DepArgumentError < DepDefinitionError
   end
 
+  # A DepRequirement is a representation of a dep being called - its name,
+  # along with the arguments that will be passed to it.
+  #
+  # DepRequirement is used internally by babushka when deps are required with
+  # arguments using "name".with(args). This allows babushka to delay loading
+  # the dep in question until the moment it's called.
+  class DepRequirement < Struct.new(:name, :args)
+  end
+
+
   class Dep
     include LogHelpers
     extend LogHelpers
-    include PathHelpers
-    extend SuggestHelpers
-
-    # This class is used for deps that aren't defined against a meta dep. Using
-    # this class with the default values it contains means that the code below
-    # can be simpler, because at the code level everything is defined against
-    # a 'template' of some sort; some are just BaseTemplate, and some are
-    # actual meta deps.
-    class BaseTemplate
-      def self.contextual_name; name end
-      def self.suffixed?; false end
-      def self.context_class; DepContext end
-    end
-
-    # A Requirement is a representation of a dep being called - its name, along
-    # with the arguments that will be passed to it.
-    #
-    # Requirement is used internally by babushka when deps are required with
-    # arguments using "name".with(args). This allows babushka to delay loading
-    # the dep in question until the moment it's called.
-    class Requirement < Struct.new(:name, :args)
-    end
 
     attr_reader :name, :params, :args, :opts, :vars, :dep_source, :load_path
     attr_accessor :result_message
@@ -48,7 +36,7 @@ module Babushka
     def initialize name, source, params, opts, block
       if name.empty?
         raise InvalidDepName, "Deps can't have empty names."
-      elsif /\A[[:print:]]+\z/i !~ name
+      elsif /[[:cntrl:]]/mu =~ name
         raise InvalidDepName, "The dep name '#{name}' contains nonprintable characters."
       elsif /\// =~ name
         raise InvalidDepName, "The dep name '#{name}' contains '/', which isn't allowed (logs are named after deps, and filenames can't contain '/')."
@@ -66,24 +54,25 @@ module Babushka
         @dep_source = source
         @load_path = Base.sources.current_load_path
         @dep_source.deps.register self
-        assign_template if Base.sources.current_real_load_source.nil?
-        @dep_defined = @_cached_process = nil # false represents failure for these two.
       end
     end
 
     def context
-      define! if @context.nil?
-      @context
+      @context ||= template.context_class.new(self, &@block)
     end
 
+    # Attempt to retrieve the template specified in +opts[:template]+. If the
+    # template name includes a source prefix, it is searched for within the
+    # corresponding source. Otherwise, it is searched for in the current source
+    # and the core sources.
     def template
-      assign_template if @template.nil?
-      @template
-    end
-
-    # Returns true if +#define!+ has aready successfully run on this dep.
-    def dep_defined?
-      @dep_defined
+      @template ||= if opts[:template]
+        Base.sources.template_for(opts[:template], :from => dep_source).tap {|t|
+          raise TemplateNotFound, "There is no template named '#{opts[:template]}' to define '#{name}' against." if t.nil?
+        }
+      else
+        Base.sources.template_for(suffix, :from => dep_source) || self.class.base_template
+      end
     end
 
     # Look up the dep specified by +dep_name+, yielding it to the block if it
@@ -93,9 +82,9 @@ module Babushka
     # this same method on the one chosen by the user, if any.
     def self.find_or_suggest dep_name, opts = {}, &block
       if (dep = Dep(dep_name, opts)).nil?
-        log "#{dep_name.to_s.colorize 'grey'} #{"<- this dep isn't defined!".colorize('red')}"
-        suggestion = suggest_value_for(dep_name, Base.sources.current_names)
-        Dep.find_or_suggest suggestion, opts, &block unless suggestion.nil?
+        log_stderr "#{dep_name.to_s.colorize 'grey'} #{"<- this dep isn't defined!".colorize('red')}"
+        suggestions = Base.sources.current_names.similar_to(dep_name.to_s)
+        log "Perhaps you meant #{suggestions.map {|s| "'#{s}'" }.to_list(:conj => 'or')}?".colorize('grey') if suggestions.any?
       elsif block.nil?
         dep
       else
@@ -135,7 +124,11 @@ module Babushka
     # suffix, if any. Unlike +#basename+, this method will return anything that
     # looks like a template suffix, even if it doesn't match a template.
     def suffix
-      name.scan(MetaDep::TEMPLATE_NAME_MATCH).flatten.first
+      name.scan(DepTemplate::TEMPLATE_NAME_MATCH).flatten.first
+    end
+
+    def cache_key
+      DepRequirement.new(name, @params.map {|p| @args[p].try(:current_value) })
     end
 
     def with *args
@@ -146,6 +139,7 @@ module Babushka
       end.map_values {|k,v|
         Parameter.for(k, v)
       }
+      @context = nil # To re-evaluate parameter.default() and friends.
       self
     end
 
@@ -156,15 +150,13 @@ module Babushka
     # altering the system. It can cause failures, though, because some deps
     # have requirements that need to be met before the dep can perform its
     # +met?+ check.
-    #
-    # TODO: In future, there will be support for specifying that in the DSL.
     def met? *args
-      with(*args).process :dry_run => true, :top_level => true
+      with(*args).process :dry_run => true
     end
 
     # Entry point for a full met?/meet +#process+ run.
     def meet *args
-      with(*args).process :dry_run => false, :top_level => true
+      with(*args).process :dry_run => false
     end
 
     # Trigger a dep run with this dep at the top of the tree.
@@ -195,7 +187,7 @@ module Babushka
     # example, if a dep detects that the existing version of a package is
     # broken in some way that requires manual intervention, then there's no
     # use running the +meet+ block. In this circumstance, you can call
-    # +#unmeetable+, which raises an +UnmeetableDep+ exception. Babushka will
+    # +#unmeetable!+, which raises an +UnmeetableDep+ exception. Babushka will
     # rescue it and consider the dep unmeetable (that is, it will just allow
     # the dep to fail without attempting to meet it).
     #
@@ -222,64 +214,21 @@ module Babushka
     # webserver is running, for example by using `netstat` to check that
     # something is listening on port 80.
     def process with_opts = {}
-      task.opts.update with_opts
-      (cached? ? cached_result : process_and_cache).tap {
-        Base.sources.uncache! if with_opts[:top_level]
-      }
-    end
-
-    private
-
-    def define_or_complain!
-      @dep_defined = begin
-        define!
-      rescue StandardError => e
-        log_exception_in_dep(e)
-        false
-      end
-    end
-
-    # Attempt to look up the template this dep was defined against (or if no
-    # template was specified, BaseTemplate), and then define the dep against
-    # it. If an error occurs, the backtrace point within the dep from which the
-    # exception was triggered is logged, as well as the actual exception point.
-    def define!
-      if dep_defined?
-        debug "#{name}: already defined."
-      elsif dep_defined? == false
-        debug "#{name}: defining already failed."
-      elsif template
-        debug "(defining #{name} against #{template.contextual_name})"
-        define_dep!
-      end
-      dep_defined?
+      Base.task.cache { process_with_caching(with_opts) }
     end
 
-    # Create a context for this dep from its template, and then process the
-    # dep's outer block in that context.
-    #
-    # This results in the details of the dep being stored, like the
-    # implementation of +met?+ and +meet+, as well as its +requires+ list and
-    # any other items defined at the top level.
-    def define_dep!
-      @context = template.context_class.new self, &@block
-      context.define!
-      @dep_defined = true
+    def process_with_caching with_opts = {}
+      Base.task.opts.update with_opts
+      Base.task.cached(
+        cache_key, :hit => lambda {|value| log_cached(value) }
+      ) {
+        log logging_name, :closing_status => (Base.task.opt(:dry_run) ? :dry_run : true) do
+          process!
+        end
+      }
     end
 
-    # Attempt to retrieve the template specified in +opts[:template]+. If the
-    # template name includes a source prefix, it is searched for within the
-    # corresponding source. Otherwise, it is searched for in the current source
-    # and the core sources.
-    def assign_template
-      @template = if opts[:template]
-        Base.sources.template_for(opts[:template], :from => dep_source).tap {|t|
-          raise TemplateNotFound, "There is no template named '#{opts[:template]}' to define '#{name}' against." if t.nil?
-        }
-      else
-        Base.sources.template_for(suffix, :from => dep_source) || self.class.base_template
-      end
-    end
+    private
 
     def self.base_template
       BaseTemplate
@@ -301,32 +250,22 @@ module Babushka
       if !args.empty? && args.length != params.length
         raise DepArgumentError, "The dep '#{name}' accepts #{params.length} argument#{'s' unless params.length == 1}, but #{args.length} #{args.length == 1 ? 'was' : 'were'} passed."
       end
-      params.inject({}) {|hsh,param| hsh[param] = args.shift; hsh }
+      Hash[params.zip(args)]
     end
 
-    def process_and_cache
-      log logging_name, :closing_status => (task.opt(:dry_run) ? :dry_run : true) do
-        if dep_defined? == false
-          # Only log about define errors if the define previously failed...
-          log_error "This dep isn't defined. Perhaps there was a load error?"
-        elsif !define_or_complain!
-          # ... not if it failed as part of this process, since that should log anyway.
-        elsif task.callstack.include? self
-          log_error "Oh crap, endless loop! (#{task.callstack.push(self).drop_while {|dep| dep != self }.map(&:name).join(' -> ')})"
-        elsif !opts[:for].nil? && !Base.host.matches?(opts[:for])
-          log_ok "Not required on #{Base.host.differentiator_for opts[:for]}."
-        else
-          task.callstack.push self
-          process_this_dep.tap {
-            task.callstack.pop
-          }
-        end
+    def process!
+      if context.failed?
+        log_error "This dep previously failed to load."
+      elsif Base.task.callstack.include? self
+        log_error "Oh crap, endless loop! (#{Base.task.callstack.push(self).drop_while {|dep| dep != self }.map(&:name).join(' -> ')})"
+      elsif !opts[:for].nil? && !Babushka.host.matches?(opts[:for])
+        log_ok "Not required on #{Babushka.host.differentiator_for opts[:for]}."
+      else
+        Base.task.callstack.push self
+        process_tree.tap {
+          Base.task.callstack.pop
+        }
       end
-    end
-
-    def process_this_dep
-      process_task(:setup)
-      process_deps and process_self
     rescue UnmeetableDep => e
       log_error e.message
       log "I don't know how to fix that, so it's up to you. :)"
@@ -337,32 +276,53 @@ module Babushka
       nil
     end
 
-    def process_deps accessor = :requires
-      requirements_for(accessor).send(task.opt(:dry_run) ? :each : :all?) do |requirement|
-        Dep.find_or_suggest requirement.name, :from => dep_source do |dep|
-          dep.with(*requirement.args).process
-        end
+    # Process the tree descending from this dep (first the dependencies, then
+    # the dep itself).
+    def process_tree
+      process_task(:setup)
+      process_requirements and process_self
+    end
+
+    # Process each of the requirements of this dep in order. If this is a dry
+    # run, check every one; otherwise, require success from all and fail fast.
+    #
+    # Each dep recursively processes its own requirements. Hence, this is the
+    # method that recurses down the dep tree.
+    def process_requirements accessor = :requires
+      if Base.task.opt(:dry_run)
+        requirements_for(accessor).map {|r| process_requirement(r) }.all?
+      else
+        requirements_for(accessor).all? {|r| process_requirement(r) }
+      end
+    end
+
+    def process_requirement requirement
+      Dep.find_or_suggest requirement.name, :from => dep_source do |dep|
+        dep.with(*requirement.args).process_with_caching
       end
+    rescue SourceLoadError => e
+      Babushka::Logging.log_exception(e)
     end
 
+    # Process this dep, assuming all its requirements are satisfied. This is
+    # the method that implements the met? -> meet -> met? logic that is what
+    # deps are all about. For details, see the documentation for Dep#process.
     def process_self
-      cd context.run_in do
-        process_met_task(:initial => true) {
-          if task.opt(:dry_run)
-            false # unmet
+      process_met_task(:initial => true) {
+        if Base.task.opt(:dry_run)
+          false # unmet
+        else
+          process_task(:prepare)
+          if !process_requirements(:requires_when_unmet)
+            false # install-time deps unmet
           else
-            process_task(:prepare)
-            if !process_deps(:requires_when_unmet)
-              false # install-time deps unmet
-            else
-              log 'meet' do
-                process_task(:before) and process_task(:meet) and process_task(:after)
-              end
-              process_met_task
+            log 'meet' do
+              process_task(:before) and process_task(:meet) and process_task(:after)
             end
+            process_met_task
           end
-        }
-      end
+        end
+      }
     end
 
     def process_met_task task_opts = {}, &block
@@ -372,7 +332,7 @@ module Babushka
     end
 
     def run_met_task task_opts = {}
-      cache_process(process_task(:met?)).tap {|result|
+      process_task(:met?).tap {|result|
         log result_message, :as => (:error unless result || task_opts[:initial]) unless result_message.nil?
         self.result_message = nil
       }
@@ -380,16 +340,15 @@ module Babushka
 
     def process_task task_name
       # log "calling #{name} / #{task_name}"
-      track_block_for(task_name) if Base.task.opt(:track_blocks)
-      context.instance_eval(&context.send(task_name))
+      context.invoke(task_name)
     end
 
     def requirements_for list_name
       context.send(list_name).map {|dep_or_requirement|
-        if dep_or_requirement.is_a?(Requirement)
+        if dep_or_requirement.is_a?(DepRequirement)
           dep_or_requirement
         else
-          Requirement.new(dep_or_requirement, [])
+          DepRequirement.new(dep_or_requirement, [])
         end
       }
     end
@@ -403,56 +362,23 @@ module Babushka
     end
 
     def log_exception_in_dep e
-      log_error e.message
+      Babushka::Logging.log_exception(e)
       advice = e.is_a?(DepDefinitionError) ? "Looks like a problem with '#{name}' - check" : "Check"
       log "#{advice} #{(e.backtrace.detect {|l| l[load_path.to_s] } || load_path).sub(/\:in [^:]+$/, '')}." unless load_path.nil?
-      debug e.backtrace * "\n"
     end
 
-    def track_block_for task_name
-      if context.has_block? task_name
-        file, line = *context.file_and_line_for(task_name)
-        shell "mate '#{file}' -l #{line}" unless file.nil? || line.nil?
-        sleep 2
+    def log_cached result
+      if result
+        log "#{Logging::TickChar} #{name} (cached)".colorize('green')
+      elsif Base.task.opt(:dry_run)
+        log "~ #{name} (cached)".colorize('blue')
       end
     end
 
-    def cached_result
-      cached_process.tap {|result|
-        if result
-          log "#{Logging::TickChar} #{name} (cached)".colorize('green')
-        elsif task.opt(:dry_run)
-          log "~ #{name} (cached)".colorize('blue')
-        else
-          log "#{Logging::CrossChar} #{name} (cached)".colorize('red')
-        end
-      }
-    end
-    def cached?
-      !@_cached_process.nil?
-    end
-    def uncache!
-      @_cached_process = nil
-    end
-    def cached_process
-      @_cached_process
-    end
-    def cache_process value
-      @_cached_process = (value.nil? ? false : value)
-    end
-
     def suffixed?
       !opts[:template] && template != BaseTemplate
     end
 
-    def payload
-      context.payload
-    end
-
-    def task
-      Base.task
-    end
-
     public
 
     def inspect
@@ -460,8 +386,8 @@ module Babushka
     end
 
     def defined_info
-      if dep_defined?
-        "#{"(#{'un' unless cached_process}met) " if cached?}<- [#{context.requires.join(', ')}]"
+      if context.loaded?
+        "<- [#{context.requires.join(', ')}]"
       else
         "(not defined yet)"
       end