Run pychecker over most scripts in depot_tools. Catched a few bugs.

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 56 matching lines @@
 
 __author__ = "darinf@gmail.com (Darin Fisher)"
 __version__ = "0.3.3"
 
 import errno
 import logging
 import optparse
 import os
 import pprint
 import re
-import stat
 import sys
 import urlparse
 import urllib
 
 import gclient_scm
 import gclient_utils
-from gclient_utils import Error, FileRead, FileWrite
 
 # default help text
 DEFAULT_USAGE_TEXT = (
 """usage: %prog <subcommand> [options] [--] [svn options/args...]
 a wrapper for managing a set of client modules in svn.
 Version """ + __version__ + """
 
 subcommands:
    cleanup
    config
@@ skipping 210 matching lines @@
     self._config_dict = {}
     self._deps_hooks = []
 
   def SetConfig(self, content):
     self._config_dict = {}
     self._config_content = content
     try:
       exec(content, self._config_dict)
     except SyntaxError, e:
       try:
+        __pychecker__ = 'no-objattrs'
         # Try to construct a human readable error message
         error_message = [
             'There is a syntax error in your configuration file.',
             'Line #%s, character %s:' % (e.lineno, e.offset),
             '"%s"' % re.sub(r'[\r\n]*$', '', e.text) ]
       except:
         # Something went wrong, re-raise the original exception
         raise e
       else:
         # Raise a new exception with the human readable message:
-        raise Error('\n'.join(error_message))
+        raise gclient_utils.Error('\n'.join(error_message))
 
   def SaveConfig(self):
-    FileWrite(os.path.join(self._root_dir, self._options.config_filename),
-              self._config_content)
+    gclient_utils.FileWrite(os.path.join(self._root_dir,
+                                         self._options.config_filename),
+                            self._config_content)
 
   def _LoadConfig(self):
-    client_source = FileRead(os.path.join(self._root_dir,
-                                          self._options.config_filename))
+    client_source = gclient_utils.FileRead(
+        os.path.join(self._root_dir, self._options.config_filename))
     self.SetConfig(client_source)
 
   def ConfigContent(self):
     return self._config_content
 
   def GetVar(self, key, default=None):
     return self._config_dict.get(key, default)
 
   @staticmethod
   def LoadCurrentConfig(options, from_dir=None):
@@ skipping 26 matching lines @@
   def _SaveEntries(self, entries):
     """Creates a .gclient_entries file to record the list of unique checkouts.
 
     The .gclient_entries file lives in the same directory as .gclient.
 
     Args:
       entries: A sequence of solution names.
     """
     text = "entries = \\\n" + pprint.pformat(entries, 2) + '\n'
     file_path = os.path.join(self._root_dir, self._options.entries_filename)
-    FileWrite(file_path, text)
+    gclient_utils.FileWrite(file_path, text)
 
   def _ReadEntries(self):
     """Read the .gclient_entries file for the given client.
 
     Args:
       client: The client for which the entries file should be read.
 
     Returns:
       A sequence of solution names, which will be empty if there is the
       entries file hasn't been created yet.
     """
     scope = {}
     filename = os.path.join(self._root_dir, self._options.entries_filename)
     if not os.path.exists(filename):
       return []
-    exec(FileRead(filename), scope)
+    exec(gclient_utils.FileRead(filename), scope)
     return scope["entries"]
 
   class FromImpl:
     """Used to implement the From syntax."""
 
     def __init__(self, module_name):
       self.module_name = module_name
 
     def __str__(self):
       return 'From("%s")' % self.module_name
 
   class _VarImpl:
     def __init__(self, custom_vars, local_scope):
       self._custom_vars = custom_vars
       self._local_scope = local_scope
 
     def Lookup(self, var_name):
       """Implements the Var syntax."""
       if var_name in self._custom_vars:
         return self._custom_vars[var_name]
       elif var_name in self._local_scope.get("vars", {}):
         return self._local_scope["vars"][var_name]
-      raise Error("Var is not defined: %s" % var_name)
+      raise gclient_utils.Error("Var is not defined: %s" % var_name)
 
   def _ParseSolutionDeps(self, solution_name, solution_deps_content,
                          custom_vars):
     """Parses the DEPS file for the specified solution.
 
     Args:
       solution_name: The name of the solution to query.
       solution_deps_content: Content of the DEPS file for the solution
       custom_vars: A dict of vars to override any vars defined in the DEPS file.
 
@@ skipping 113 matching lines @@
             if d in deps and type(deps[d]) != str:
               if url.module_name == deps[d].module_name:
                 continue
           else:
             parsed_url = urlparse.urlparse(url)
             scheme = parsed_url[0]
             if not scheme:
               # A relative url. Fetch the real base.
               path = parsed_url[2]
               if path[0] != "/":
-                raise Error(
+                raise gclient_utils.Error(
                     "relative DEPS entry \"%s\" must begin with a slash" % d)
               # Create a scm just to query the full url.
               scm = gclient_scm.CreateSCM(solution["url"], self._root_dir,
                                            None)
               url = scm.FullUrlForRelativeUrl(url)
         if d in deps and deps[d] != url:
-          raise Error(
+          raise gclient_utils.Error(
               "Solutions have conflicting versions of dependency \"%s\"" % d)
         if d in solution_urls and solution_urls[d] != url:
-          raise Error(
+          raise gclient_utils.Error(
               "Dependency \"%s\" conflicts with specified solution" % d)
         # Grab the dependency.
         deps[d] = url
     return deps
 
   def _RunHookAction(self, hook_dict, matching_file_list):
     """Runs the action from a single hook.
     """
     command = hook_dict['action'][:]
     if command[0] == 'python':
@@ skipping 32 matching lines @@
     # changed so we always run all hooks.
     if self._options.force or is_using_git:
       for hook_dict in hooks:
         self._RunHookAction(hook_dict, [])
       return
 
     # Run hooks on the basis of whether the files from the gclient operation
     # match each hook's pattern.
     for hook_dict in hooks:
       pattern = re.compile(hook_dict['pattern'])
-      matching_file_list = [file for file in file_list if pattern.search(file)]
+      matching_file_list = [f for f in file_list if pattern.search(f)]
       if matching_file_list:
         self._RunHookAction(hook_dict, matching_file_list)
 
   def RunOnDeps(self, command, args):
     """Runs a command on each dependency in a client and its dependencies.
 
     The module's dependencies are specified in its top-level DEPS files.
 
     Args:
       command: The command to use (e.g., 'status' or 'diff')
       args: list of str - extra arguments to add to the command line.
 
     Raises:
       Error: If the client has conflicting entries.
     """
     if not command in self.supported_commands:
-      raise Error("'%s' is an unsupported command" % command)
+      raise gclient_utils.Error("'%s' is an unsupported command" % command)
 
     # Check for revision overrides.
     revision_overrides = {}
     for revision in self._options.revisions:
       if revision.find("@") == -1:
-        raise Error(
+        raise gclient_utils.Error(
             "Specify the full dependency when specifying a revision number.")
       revision_elem = revision.split("@")
       # Disallow conflicting revs
       if revision_overrides.has_key(revision_elem[0]) and \
          revision_overrides[revision_elem[0]] != revision_elem[1]:
-        raise Error(
+        raise gclient_utils.Error(
             "Conflicting revision numbers specified.")
       revision_overrides[revision_elem[0]] = revision_elem[1]
 
     solutions = self.GetVar("solutions")
     if not solutions:
-      raise Error("No solution specified")
+      raise gclient_utils.Error("No solution specified")
 
     # When running runhooks --force, there's no need to consult the SCM.
     # All known hooks are expected to run unconditionally regardless of working
     # copy state, so skip the SCM status check.
     run_scm = not (command == 'runhooks' and self._options.force)
 
     entries = {}
     entries_deps_content = {}
     file_list = []
     # Run on the base solutions first.
     for solution in solutions:
       name = solution["name"]
       deps_file = solution.get("deps_file", self._options.deps_file)
       if '/' in deps_file or '\\' in deps_file:
-        raise Error("deps_file name must not be a path, just a filename.")
+        raise gclient_utils.Error('deps_file name must not be a path, just a '
+                                  'filename.')
       if name in entries:
-        raise Error("solution %s specified more than once" % name)
+        raise gclient_utils.Error("solution %s specified more than once" % name)
       url = solution["url"]
       entries[name] = url
       if run_scm and url:
         self._options.revision = revision_overrides.get(name)
         scm = gclient_scm.CreateSCM(url, self._root_dir, name)
         scm.RunCommand(command, self._options, args, file_list)
-        file_list = [os.path.join(name, file.strip()) for file in file_list]
+        file_list = [os.path.join(name, f.strip()) for f in file_list]
         self._options.revision = None
       try:
-        deps_content = FileRead(os.path.join(self._root_dir, name,
-                                             deps_file))
+        deps_content = gclient_utils.FileRead(
+            os.path.join(self._root_dir, name, deps_file))
       except IOError, e:
         if e.errno != errno.ENOENT:
           raise
         deps_content = ""
       entries_deps_content[name] = deps_content
 
     # 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 = deps[d]
         entries[d] = url
         if run_scm:
           self._options.revision = revision_overrides.get(d)
           scm = gclient_scm.CreateSCM(url, self._root_dir, d)
           scm.RunCommand(command, self._options, args, file_list)
           self._options.revision = None
 
     # Second pass for inherited deps (via the From keyword)
     for d in deps_to_process:
       if type(deps[d]) != str:
-        sub_deps = self._ParseSolutionDeps(
-                           deps[d].module_name,
-                           FileRead(os.path.join(self._root_dir,
-                                                 deps[d].module_name,
-                                                 self._options.deps_file)),
-                           {})
+        filename = os.path.join(self._root_dir,
+                                deps[d].module_name,
+                                self._options.deps_file)
+        content =  gclient_utils.FileRead(filename)
+        sub_deps = self._ParseSolutionDeps(deps[d].module_name, content, {})
         url = sub_deps[d]
         entries[d] = url
         if run_scm:
           self._options.revision = revision_overrides.get(d)
           scm = gclient_scm.CreateSCM(url, self._root_dir, d)
           scm.RunCommand(command, self._options, args, file_list)
           self._options.revision = None
 
     # Convert all absolute paths to relative.
     for i in range(len(file_list)):
@@ skipping 60 matching lines @@
     NOTE: Unlike RunOnDeps this does not require a local checkout and is run
     on the Pulse master. It MUST NOT execute hooks.
 
     Raises:
       Error: If the client has conflicting entries.
     """
     # Check for revision overrides.
     revision_overrides = {}
     for revision in self._options.revisions:
       if revision.find("@") < 0:
-        raise Error(
+        raise gclient_utils.Error(
             "Specify the full dependency when specifying a revision number.")
       revision_elem = revision.split("@")
       # Disallow conflicting revs
       if revision_overrides.has_key(revision_elem[0]) and \
          revision_overrides[revision_elem[0]] != revision_elem[1]:
-        raise Error(
+        raise gclient_utils.Error(
             "Conflicting revision numbers specified.")
       revision_overrides[revision_elem[0]] = revision_elem[1]
 
     solutions = self.GetVar("solutions")
     if not solutions:
-      raise Error("No solution specified")
+      raise gclient_utils.Error("No solution specified")
 
     entries = {}
     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, revision_overrides[name])
         else:
           scm = gclient_scm.CreateSCM(solution["url"], self._root_dir, name)
           return (original_url, scm.revinfo(self._options, [], None))
       else:
         url_components = original_url.split("@")
         if revision_overrides.has_key(name):
           return (url_components[0], revision_overrides[name])
         else:
           return (url_components[0], 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)
+        raise gclient_utils.Error("solution %s specified more than once" % name)
       (url, rev) = GetURLAndRev(name, solution["url"])
       entries[name] = "%s@%s" % (url, rev)
       # TODO(aharper): SVN/SCMWrapper cleanup (non-local commandset)
       entries_deps_content[name] = gclient_scm.CaptureSVN(
                                      ["cat",
                                       "%s/%s@%s" % (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@%s" % (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 = gclient_scm.CaptureSVN(
-                                ["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)),
-                           {})
+          raise gclient_utils.Error("From %s missing revisioned url" %
+                                        deps[d].module_name)
+        content =  gclient_utils.FileRead(os.path.join(self._root_dir,
+                                                       deps[d].module_name,

[Dirk Pranke, 2009/11/10 19:49:24]

You're sure this file will already be local? (I'm not 100% clear at what points
this code is called).

[M-A Ruel, 2009/11/10 20:02:23]

If you look at the old code, it was running [svn cat svn://...] and put it in
deps_parent_content. Note this variable is not used afterward (!) So I removed
all this code altogether.

I kept the code to have sub_deps but split it since the previous code was
unreadable.

+                                                       self._options.deps_file))
+        sub_deps = self._ParseSolutionDeps(deps[d].module_name, content, {})
         (url, rev) = GetURLAndRev(d, sub_deps[d])
         entries[d] = "%s@%s" % (url, rev)
     print(";\n\n".join(["%s: %s" % (x, entries[x])
                         for x in sorted(entries.keys())]))
 
 
 ## gclient commands.
 
 
 def DoCleanup(options, args):
   """Handle the cleanup subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
   client = GClient.LoadCurrentConfig(options)
   if not client:
-    raise Error("client not configured; see 'gclient config'")
+    raise gclient_utils.Error("client not configured; see 'gclient config'")
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
     print(client.ConfigContent())
   return client.RunOnDeps('cleanup', args)
 
 
 def DoConfig(options, args):
   """Handle the config subcommand.
 
   Args:
     options: If options.spec set, a string providing contents of config file.
     args: The command line args.  If spec is not set,
           then args[0] is a string URL to get for config file.
 
   Raises:
     Error: on usage error
   """
   if len(args) < 1 and not options.spec:
-    raise Error("required argument missing; see 'gclient help config'")
+    raise gclient_utils.Error("required argument missing; see 'gclient help "
+                              "config'")
   if os.path.exists(options.config_filename):
-    raise Error("%s file already exists in the current directory" %
-                options.config_filename)
+    raise gclient_utils.Error("%s file already exists in the current directory"
+                                  % options.config_filename)
   client = GClient('.', options)
   if options.spec:
     client.SetConfig(options.spec)
   else:
     # TODO(darin): it would be nice to be able to specify an alternate relpath
     # for the given URL.
     base_url = args[0].rstrip('/')
     name = base_url.split("/")[-1]
     safesync_url = ""
     if len(args) > 1:
       safesync_url = args[1]
     client.SetDefaultConfig(name, base_url, safesync_url)
   client.SaveConfig()
 
 
 def DoExport(options, args):
   """Handle the export subcommand.
 
   Raises:
     Error: on usage error
   """
   if len(args) != 1:
-    raise Error("Need directory name")
+    raise gclient_utils.Error("Need directory name")
   client = GClient.LoadCurrentConfig(options)
 
   if not client:
-    raise Error("client not configured; see 'gclient config'")
+    raise gclient_utils.Error("client not configured; see 'gclient config'")
 
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
     print(client.ConfigContent())
   return client.RunOnDeps('export', args)
 
 def DoHelp(options, args):
   """Handle the help subcommand giving help for another subcommand.
 
   Raises:
     Error: if the command is unknown.
   """
+  __pychecker__ = 'unusednames=options'
   if len(args) == 1 and args[0] in COMMAND_USAGE_TEXT:
     print(COMMAND_USAGE_TEXT[args[0]])
   else:
-    raise Error("unknown subcommand '%s'; see 'gclient help'" % args[0])
+    raise gclient_utils.Error("unknown subcommand '%s'; see 'gclient help'" %
+                                  args[0])
 
 
 def DoPack(options, args):
   """Handle the pack subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
   client = GClient.LoadCurrentConfig(options)
   if not client:
-    raise Error("client not configured; see 'gclient config'")
+    raise gclient_utils.Error("client not configured; see 'gclient config'")
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
     print(client.ConfigContent())
   return client.RunOnDeps('pack', args)
 
 
 def DoStatus(options, args):
   """Handle the status subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
   client = GClient.LoadCurrentConfig(options)
   if not client:
-    raise Error("client not configured; see 'gclient config'")
+    raise gclient_utils.Error("client not configured; see 'gclient config'")
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
     print(client.ConfigContent())
   return client.RunOnDeps('status', args)
 
 
 def DoUpdate(options, args):
   """Handle the update and sync subcommands.
 
   Raises:
     Error: if client isn't configured properly.
   """
   client = GClient.LoadCurrentConfig(options)
 
   if not client:
-    raise Error("client not configured; see 'gclient config'")
+    raise gclient_utils.Error("client not configured; see 'gclient config'")
 
   if not options.head:
     solutions = client.GetVar('solutions')
     if solutions:
       for s in solutions:
         if s.get('safesync_url', ''):
           # rip through revisions and make sure we're not over-riding
           # something that was explicitly passed
           has_key = False
           for r in options.revisions:
@@ skipping 16 matching lines @@
 
 
 def DoDiff(options, args):
   """Handle the diff subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
   client = GClient.LoadCurrentConfig(options)
   if not client:
-    raise Error("client not configured; see 'gclient config'")
+    raise gclient_utils.Error("client not configured; see 'gclient config'")
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
     print(client.ConfigContent())
   return client.RunOnDeps('diff', args)
 
 
 def DoRevert(options, args):
   """Handle the revert subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
   client = GClient.LoadCurrentConfig(options)
   if not client:
-    raise Error("client not configured; see 'gclient config'")
+    raise gclient_utils.Error("client not configured; see 'gclient config'")
   return client.RunOnDeps('revert', args)
 
 
 def DoRunHooks(options, args):
   """Handle the runhooks subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
   client = GClient.LoadCurrentConfig(options)
   if not client:
-    raise Error("client not configured; see 'gclient config'")
+    raise gclient_utils.Error("client not configured; see 'gclient config'")
   if options.verbose:
     # Print out the .gclient file.  This is longer than if we just printed the
     # client dict, but more legible, and it might contain helpful comments.
     print(client.ConfigContent())
   options.force = True
   return client.RunOnDeps('runhooks', args)
 
 
 def DoRevInfo(options, args):
   """Handle the revinfo subcommand.
 
   Raises:
     Error: if client isn't configured properly.
   """
+  __pychecker__ = 'unusednames=args'
   client = GClient.LoadCurrentConfig(options)
   if not client:
-    raise Error("client not configured; see 'gclient config'")
+    raise gclient_utils.Error("client not configured; see 'gclient config'")
   client.PrintRevInfo()
 
 
 gclient_command_map = {
   "cleanup": DoCleanup,
   "config": DoConfig,
   "diff": DoDiff,
   "export": DoExport,
   "help": DoHelp,
   "pack": DoPack,
   "status": DoStatus,
   "sync": DoUpdate,
   "update": DoUpdate,
   "revert": DoRevert,
   "runhooks": DoRunHooks,
   "revinfo" : DoRevInfo,
 }
 
 
 def DispatchCommand(command, options, args, command_map=None):
   """Dispatches the appropriate subcommand based on command line arguments."""
   if command_map is None:
     command_map = gclient_command_map
 
   if command in command_map:
     return command_map[command](options, args)
   else:
-    raise Error("unknown subcommand '%s'; see 'gclient help'" % command)
+    raise gclient_utils.Error("unknown subcommand '%s'; see 'gclient help'" %
+                                  command)
 
 
 def Main(argv):
   """Parse command line arguments and dispatch command."""
 
   option_parser = optparse.OptionParser(usage=DEFAULT_USAGE_TEXT,
                                         version=__version__)
   option_parser.disable_interspersed_args()
   option_parser.add_option("", "--force", action="store_true", default=False,
                            help=("(update/sync only) force update even "
@@ skipping 57 matching lines @@
   options.entries_filename = ".gclient_entries"
   options.deps_file = "DEPS"
 
   options.platform = sys.platform
   return DispatchCommand(command, options, args)
 
 
 if "__main__" == __name__:
   try:
     result = Main(sys.argv)
-  except Error, e:
+  except gclient_utils.Error, e:
     print >> sys.stderr, "Error: %s" % str(e)
     result = 1
   sys.exit(result)
 
 # vim: ts=2:sw=2:tw=80:et: