[cr tool] Make context implicit

tools/cr/cr/base/host.py

 # Copyright 2013 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """Module for build host support."""
 
 import os
 import pipes
 import signal
 import subprocess
@@ skipping 18 matching lines @@
   def Matches(self):
     """Detects whether this is the correct host implementation.
 
     This method is overridden by the concrete implementations.
     Returns:
       true if the plugin matches the machine it is running on.
     """
     return False
 
   @classmethod
-  def Select(cls, context):
+  def Select(cls):
     for host in cls.Plugins():
       if host.Matches():
         return host
 
-  def _Execute(self, context, command,
+  def _Execute(self, command,
                shell=False, capture=False, silent=False,
                ignore_dry_run=False, return_status=False,
                ignore_interrupt_signal=False):
     """This is the only method that launches external programs.
 
     It is a thin wrapper around subprocess.Popen that handles cr specific
-    issues. The command is expanded in the context, so that context variables
+    issues. The command is expanded in the so that context variables

[Andrew Hayden (chromium.org), 2014/03/19 18:20:06]

Search and replace is not your friend.

[iancottrell, 2014/03/19 22:17:11]

Unfortunately none of this change was amenable to search and replace, it was all
done by hand. This was probably me getting stuck trying to reword, going for
coffee, and then forgetting what I was doing when I came back :)

     are substituted.
     Args:
-      context: the cr context to run under.
       command: the command to run.
       shell: whether to run the command using the shell.
       capture: controls wether the output of the command is captured.
       ignore_dry_run: Normally, if the context is in dry run mode the command is
         printed but not executed. This flag overrides that behaviour, causing
         the command to be run anyway.
       return_status: switches the function to returning the status code rather
         the output.
       ignore_interrupt_signal: Ignore the interrupt signal (i.e., Ctrl-C) while
         the command is running. Useful for letting interactive programs manage
         Ctrl-C by themselves.
     Returns:
       the status if return_status is true, or the output if capture is true,
       otherwise nothing.
     """
-    with context.Trace():
-      command = [context.Substitute(arg) for arg in command if arg]
-    trail = context.trail
+    with cr.context.Trace():
+      command = [cr.context.Substitute(arg) for arg in command if arg]
+    trail = cr.context.trail
     if not command:
       print 'Empty command passed to execute'
       exit(1)
-    if context.verbose:
+    if cr.context.verbose:
       print ' '.join(command)
-      if context.verbose >= _TRAIL_VERBOSITY:
+      if cr.context.verbose >= _TRAIL_VERBOSITY:
         print 'Command expanded the following variables:'
         for key, value in trail:
           print '   ', key, '=', value
-    if ignore_dry_run or not context.dry_run:
+    if ignore_dry_run or not cr.context.dry_run:
       out = None
       if capture:
         out = subprocess.PIPE
       elif silent:
         out = open(os.devnull, "w")
       try:
         p = subprocess.Popen(
             command, shell=shell,
-            env={k: str(v) for k, v in context.exported.items()},
+            env={k: str(v) for k, v in cr.context.exported.items()},
             stdout=out)
       except OSError:
         print 'Failed to exec', command
         # Don't log the trail if we already have
-        if context.verbose < _TRAIL_VERBOSITY:
+        if cr.context.verbose < _TRAIL_VERBOSITY:
           print 'Variables used to build the command were:'
           for key, value in trail:
             print '   ', key, '=', value
         exit(1)
       try:
         if ignore_interrupt_signal:
           signal.signal(signal.SIGINT, signal.SIG_IGN)
         output, _ = p.communicate()
       finally:
         if ignore_interrupt_signal:
           signal.signal(signal.SIGINT, signal.SIG_DFL)
         if silent:
           out.close()
       if return_status:
         return p.returncode
       if p.returncode != 0:
         print 'Error {0} executing command {1}'.format(p.returncode, command)
         exit(p.returncode)
       return output or ''
     return ''
 
   @cr.Plugin.activemethod
-  def Shell(self, context, *command):
+  def Shell(self, *command):
     command = ' '.join([pipes.quote(arg) for arg in command])
-    return self._Execute(context, [command], shell=True,
-                         ignore_interrupt_signal=True)
+    return self._Execute([command], shell=True, ignore_interrupt_signal=True)
 
   @cr.Plugin.activemethod
-  def Execute(self, context, *command):
-    return self._Execute(context, command, shell=False)
+  def Execute(self, *command):
+    return self._Execute(command, shell=False)
 
   @cr.Plugin.activemethod
-  def ExecuteSilently(self, context, *command):
-    return self._Execute(context, command, shell=False, silent=True)
+  def ExecuteSilently(self, *command):
+    return self._Execute(command, shell=False, silent=True)
 
   @cr.Plugin.activemethod
-  def CaptureShell(self, context, *command):
-    return self._Execute(context, command,
+  def CaptureShell(self, *command):
+    return self._Execute(command,
                          shell=True, capture=True, ignore_dry_run=True)
 
   @cr.Plugin.activemethod
-  def Capture(self, context, *command):
-    return self._Execute(context, command, capture=True, ignore_dry_run=True)
+  def Capture(self, *command):
+    return self._Execute(command, capture=True, ignore_dry_run=True)
 
   @cr.Plugin.activemethod
-  def ExecuteStatus(self, context, *command):
-    return self._Execute(context, command,
+  def ExecuteStatus(self, *command):
+    return self._Execute(command,
                          ignore_dry_run=True, return_status=True)
 
   @cr.Plugin.activemethod
   def YesNo(self, question, default=True):
     """Ask the user a yes no question
 
     This blocks until the user responds.
     Args:
       question: The question string to show the user
       default: True if the default response is Yes
@@ skipping 18 matching lines @@
     result = []
     extensions = ['']
     extensions.extend(os.environ.get('PATHEXT', '').split(os.pathsep))
     for path in os.environ.get('PATH', '').split(os.pathsep):
       partial = os.path.join(path, name)
       for extension in extensions:
         filename = partial + extension
         if os.path.exists(filename) and filename not in result:
           result.append(filename)
     return result