Cleanup gclient.py use of options where unnecessary.

gclient.py

 #!/usr/bin/python
 #
 # Copyright 2008 Google Inc.  All Rights Reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #      http://www.apache.org/licenses/LICENSE-2.0
 #
@@ skipping 457 matching lines @@
   |entries| is a list of paths to check."""
   for path in paths:
     if os.path.exists(os.path.join(root, path, '.git')):
       return True
   return False
 
 # -----------------------------------------------------------------------------
 # SVN utils:
 
 
-def RunSVN(options, args, in_directory):
+def RunSVN(args, in_directory):
   """Runs svn, sending output to stdout.
 
   Args:
     args: A sequence of command line parameters to be passed to svn.
     in_directory: The directory where svn is to be run.
 
   Raises:
     Error: An error occurred while running the svn command.
   """
   c = [SVN_COMMAND]
   c.extend(args)
 
   SubprocessCall(c, in_directory, options.stdout)
 
 
-def CaptureSVN(options, args, in_directory):
+def CaptureSVN(args, in_directory=None, print_error=True):
   """Runs svn, capturing output sent to stdout as a string.
 
   Args:
     args: A sequence of command line parameters to be passed to svn.
     in_directory: The directory where svn is to be run.
 
   Returns:
     The output sent to stdout as a string.
   """
   c = [SVN_COMMAND]
   c.extend(args)
 
   # *Sigh*:  Windows needs shell=True, or else it won't search %PATH% for
   # the svn.exe executable, but shell=True makes subprocess on Linux fail
   # when it's called with a list because it only tries to execute the
   # first string ("svn").
-  return subprocess.Popen(c, cwd=in_directory, shell=(sys.platform == 'win32'),
-                          stdout=subprocess.PIPE).communicate()[0]
+  stderr = None
+  if print_error:
+    stderr = subprocess.PIPE
+  return subprocess.Popen(c,
+                          cwd=in_directory,
+                          shell=(sys.platform == 'win32'),
+                          stdout=subprocess.PIPE,
+                          stderr=stderr).communicate()[0]
 
 
 def RunSVNAndGetFileList(options, args, in_directory, file_list):
   """Runs svn checkout, update, or status, output to stdout.
 
   The first item in args must be either "checkout", "update", or "status".
 
   svn's stdout is parsed to collect a list of files checked out or updated.
   These files are appended to file_list.  svn's stdout is also printed to
   sys.stdout as in RunSVN.
@@ skipping 26 matching lines @@
   pattern = {
         'checkout': update_pattern,
         'status':   status_pattern,
         'update':   update_pattern,
       }[args[0]]
 
   SubprocessCallAndCapture(command, in_directory, options.stdout,
                            pattern=pattern, capture_list=file_list)
 
 
-def CaptureSVNInfo(options, relpath, in_directory):
+def CaptureSVNInfo(relpath, in_directory=None, print_error=True):
   """Returns a dictionary from the svn info output for the given file.
 
   Args:
     relpath: The directory where the working copy resides relative to
       the directory given by in_directory.
     in_directory: The directory where svn is to be run.
   """
-  dom = ParseXML(CaptureSVN(options, ["info", "--xml", relpath], in_directory))
+  output = CaptureSVN(["info", "--xml", relpath], in_directory, print_error)
+  dom = ParseXML(output)
   result = {}
   if dom:
     def C(item, f):
       if item is not None: return f(item)
     # /info/entry/
     #   url
     #   reposityory/(root|uuid)
     #   wc-info/(schedule|depth)
     #   commit/(author|date)
     # str() the results because they may be returned as Unicode, which
     # interferes with the higher layers matching up things in the deps
     # dictionary.
     # TODO(maruel): Fix at higher level instead (!)
     result['Repository Root'] = C(GetNamedNodeText(dom, 'root'), str)
     result['URL'] = C(GetNamedNodeText(dom, 'url'), str)
     result['UUID'] = C(GetNamedNodeText(dom, 'uuid'), str)
     result['Revision'] = C(GetNodeNamedAttributeText(dom, 'entry', 'revision'),
                            int)
     result['Node Kind'] = C(GetNodeNamedAttributeText(dom, 'entry', 'kind'),
                             str)
     result['Schedule'] = C(GetNamedNodeText(dom, 'schedule'), str)
     result['Path'] = C(GetNodeNamedAttributeText(dom, 'entry', 'path'), str)
     result['Copied From URL'] = C(GetNamedNodeText(dom, 'copy-from-url'), str)
     result['Copied From Rev'] = C(GetNamedNodeText(dom, 'copy-from-rev'), str)
   return result
 
 
-def CaptureSVNHeadRevision(options, url):
+def CaptureSVNHeadRevision(url):
   """Get the head revision of a SVN repository.
 
   Returns:
     Int head revision
   """
-  info = CaptureSVN(options, ["info", "--xml", url], os.getcwd())
+  info = CaptureSVN(["info", "--xml", url], os.getcwd())
   dom = xml.dom.minidom.parseString(info)
   return int(dom.getElementsByTagName('entry')[0].getAttribute('revision'))
 
 
 class FileStatus:
   def __init__(self, path, text_status, props, lock, history):
     self.path = path
     self.text_status = text_status
     self.props = props
     self.lock = lock
     self.history = history
 
   def __str__(self):
     # Emulate svn status 1.5 output.
     return (self.text_status + self.props + self.lock + self.history + ' ' +
             self.path)
 
 
-def CaptureSVNStatus(options, path):
+def CaptureSVNStatus(path):
   """Runs 'svn status' on an existing path.
 
   Args:
     path: The directory to run svn status.
 
   Returns:
     An array of FileStatus corresponding to the emulated output of 'svn status'
     version 1.5."""
-  dom = ParseXML(CaptureSVN(options, ["status", "--xml"], path))
+  dom = ParseXML(CaptureSVN(["status", "--xml"], path))
   results = []
   if dom:
     # /status/target/entry/(wc-status|commit|author|date)
     for target in dom.getElementsByTagName('target'):
       base_path = target.getAttribute('path')
       for entry in target.getElementsByTagName('entry'):
         file = entry.getAttribute('path')
         wc_status = entry.getElementsByTagName('wc-status')
         assert len(wc_status) == 1
         # Emulate svn 1.5 status ouput...
@@ skipping 81 matching lines @@
 
     if not command in commands:
       raise Error('Unknown command %s' % command)
 
     return commands[command](options, args, file_list)
 
   def cleanup(self, options, args, file_list):
     """Cleanup working copy."""
     command = ['cleanup']
     command.extend(args)
-    RunSVN(options, command, os.path.join(self._root_dir, self.relpath))
+    RunSVN(command, os.path.join(self._root_dir, self.relpath))
 
   def diff(self, options, args, file_list):
     # NOTE: This function does not currently modify file_list.
     command = ['diff']
     command.extend(args)
-    RunSVN(options, command, os.path.join(self._root_dir, self.relpath))
+    RunSVN(command, os.path.join(self._root_dir, self.relpath))
 
   def update(self, options, args, file_list):
     """Runs SCM to update or transparently checkout the working copy.
 
     All updated files will be appended to file_list.
 
     Raises:
       Error: if can't get URL for relative path.
     """
     # Only update if git is not controlling the directory.
@@ skipping 25 matching lines @@
 
     if not options.path_exists(os.path.join(self._root_dir, self.relpath)):
       # We need to checkout.
       command = ['checkout', url, os.path.join(self._root_dir, self.relpath)]
       if revision:
         command.extend(['--revision', str(revision)])
       RunSVNAndGetFileList(options, command, self._root_dir, file_list)
       return
 
     # Get the existing scm url and the revision number of the current checkout.
-    from_info = CaptureSVNInfo(options,
-                               os.path.join(self._root_dir, self.relpath, '.'),
+    from_info = CaptureSVNInfo(os.path.join(self._root_dir, self.relpath, '.'),
                                '.')
 
     if options.manually_grab_svn_rev:
       # Retrieve the current HEAD version because svn is slow at null updates.
       if not revision:
-        from_info_live = CaptureSVNInfo(options, from_info['URL'], '.')
+        from_info_live = CaptureSVNInfo(from_info['URL'], '.')
         revision = int(from_info_live['Revision'])
         rev_str = ' at %d' % revision
 
     if from_info['URL'] != components[0]:
-      to_info = CaptureSVNInfo(options, url, '.')
+      to_info = CaptureSVNInfo(url, '.')
       if from_info['Repository Root'] != to_info['Repository Root']:
         # We have different roots, so check if we can switch --relocate.
         # Subversion only permits this if the repository UUIDs match.
         if from_info['UUID'] != to_info['UUID']:
           raise Error("Can't switch the checkout to %s; UUID don't match. That "
                       "simply means in theory, gclient should verify you don't "
                       "have a local change, remove the old checkout and do a "
                       "fresh new checkout of the new repo. Contributions are "
                       "welcome." % url)
 
         # Perform the switch --relocate, then rewrite the from_url
         # to reflect where we "are now."  (This is the same way that
         # Subversion itself handles the metadata when switch --relocate
         # is used.)  This makes the checks below for whether we
         # can update to a revision or have to switch to a different
         # branch work as expected.
         # TODO(maruel):  TEST ME !
         command = ["switch", "--relocate",
                    from_info['Repository Root'],
                    to_info['Repository Root'],
                    self.relpath]
-        RunSVN(options, command, self._root_dir)
+        RunSVN(command, self._root_dir)
         from_info['URL'] = from_info['URL'].replace(
             from_info['Repository Root'],
             to_info['Repository Root'])
 
     # If the provided url has a revision number that matches the revision
     # number of the existing directory, then we don't need to bother updating.
     if not options.force and from_info['Revision'] == revision:
       if options.verbose or not forced_revision:
         print >>options.stdout, ("\n_____ %s%s" % (
             self.relpath, rev_str))
@@ skipping 12 matching lines @@
     """
     path = os.path.join(self._root_dir, self.relpath)
     if not os.path.isdir(path):
       # svn revert won't work if the directory doesn't exist. It needs to
       # checkout instead.
       print >>options.stdout, ("\n_____ %s is missing, synching instead" %
                                self.relpath)
       # Don't reuse the args.
       return self.update(options, [], file_list)
 
-    files = CaptureSVNStatus(options, path)
+    files = CaptureSVNStatus(path)
     # Batch the command.
     files_to_revert = []
     for file in files:
       file_path = os.path.join(path, file.path)
       print >>options.stdout, file_path
       # Unversioned file or unexpected unversioned file.
       if file.text_status in ('?', '~'):
         # Remove extraneous file. Also remove unexpected unversioned
         # directories. svn won't touch them but we want to delete these.
         file_list.append(file_path)
         try:
           os.remove(file_path)
         except EnvironmentError:
           RemoveDirectory(file_path)
 
       if file.text_status != '?':
         # For any other status, svn revert will work.
         file_list.append(file_path)
         files_to_revert.append(file.path)
 
     # Revert them all at once.
     if files_to_revert:
       accumulated_paths = []
       accumulated_length = 0
       command = ['revert']
       for p in files_to_revert:
         # Some shell have issues with command lines too long.
         if accumulated_length and accumulated_length + len(p) > 3072:
-          RunSVN(options, command + accumulated_paths,
+          RunSVN(command + accumulated_paths,
                  os.path.join(self._root_dir, self.relpath))
           accumulated_paths = []
           accumulated_length = 0
         else:
           accumulated_paths.append(p)
           accumulated_length += len(p)
       if accumulated_paths:
-        RunSVN(options, command + accumulated_paths,
+        RunSVN(command + accumulated_paths,
                os.path.join(self._root_dir, self.relpath))
 
   def status(self, options, args, file_list):
     """Display status information."""
     path = os.path.join(self._root_dir, self.relpath)
     command = ['status']
     command.extend(args)
     if not os.path.isdir(path):
       # svn status won't work if the directory doesn't exist.
       print >> options.stdout, (
@@ skipping 420 matching lines @@
     self._RunHooks(command, file_list, is_using_git)
 
     if command == 'update':
       # notify the user if there is an orphaned entry in their working copy.
       # TODO(darin): we should delete this directory manually if it doesn't
       # have any changes in it.
       prev_entries = self._ReadEntries()
       for entry in prev_entries:
         e_dir = os.path.join(self._root_dir, entry)
         if entry not in entries and self._options.path_exists(e_dir):
-          if CaptureSVNStatus(self._options, e_dir):
+          if CaptureSVNStatus(e_dir):
             # There are modified files in this entry
             entries[entry] = None  # Keep warning until removed.
             print >> self._options.stdout, (
                 "\nWARNING: \"%s\" is no longer part of this client.  "
                 "It is recommended that you manually remove it.\n") % entry
           else:
             # Delete the entry
             print >> self._options.stdout, ("\n________ deleting \'%s\' " +
                 "in \'%s\'") % (entry, self._root_dir)
             RemoveDirectory(e_dir)
@@ skipping 37 matching lines @@
     entries_deps_content = {}
 
     # Inner helper to generate base url and rev tuple (including honoring
     # |revision_overrides|)
     def GetURLAndRev(name, original_url):
       if original_url.find("@") < 0:
         if revision_overrides.has_key(name):
           return (original_url, int(revision_overrides[name]))
         else:
           # TODO(aharper): SVN/SCMWrapper cleanup (non-local commandset)
-          return (original_url, CaptureSVNHeadRevision(self._options,
-                                                       original_url))
+          return (original_url, CaptureSVNHeadRevision(original_url))
       else:
         url_components = original_url.split("@")
         if revision_overrides.has_key(name):
           return (url_components[0], int(revision_overrides[name]))
         else:
           return (url_components[0], int(url_components[1]))
 
     # Run on the base solutions first.
     for solution in solutions:
       name = solution["name"]
       if name in entries:
         raise Error("solution %s specified more than once" % name)
       (url, rev) = GetURLAndRev(name, solution["url"])
       entries[name] = "%s@%d" % (url, rev)
       # TODO(aharper): SVN/SCMWrapper cleanup (non-local commandset)
       entries_deps_content[name] = CaptureSVN(
-                                     self._options,
                                      ["cat",
                                       "%s/%s@%d" % (url,
                                                     self._options.deps_file,
                                                     rev)],
                                      os.getcwd())
 
     # Process the dependencies next (sort alphanumerically to ensure that
     # containing directories get populated first and for readability)
     deps = self._ParseAllDeps(entries, entries_deps_content)
     deps_to_process = deps.keys()
     deps_to_process.sort()
 
     # First pass for direct dependencies.
     for d in deps_to_process:
       if type(deps[d]) == str:
         (url, rev) = GetURLAndRev(d, deps[d])
         entries[d] = "%s@%d" % (url, rev)
 
     # Second pass for inherited deps (via the From keyword)
     for d in deps_to_process:
       if type(deps[d]) != str:
         deps_parent_url = entries[deps[d].module_name]
         if deps_parent_url.find("@") < 0:
           raise Error("From %s missing revisioned url" % deps[d].module_name)
         deps_parent_url_components = deps_parent_url.split("@")
         # TODO(aharper): SVN/SCMWrapper cleanup (non-local commandset)
         deps_parent_content = CaptureSVN(
-                                self._options,
                                 ["cat",
                                  "%s/%s@%s" % (deps_parent_url_components[0],
                                                self._options.deps_file,
                                                deps_parent_url_components[1])],
                                 os.getcwd())
         sub_deps = self._ParseSolutionDeps(
                            deps[d].module_name,
                            FileRead(os.path.join(self._root_dir,
                                                  deps[d].module_name,
                                                  self._options.deps_file)),
@@ skipping 273 matching lines @@
 
 if "__main__" == __name__:
   try:
     result = Main(sys.argv)
   except Error, e:
     print "Error: %s" % str(e)
     result = 1
   sys.exit(result)
 
 # vim: ts=2:sw=2:tw=80:et: