More work toward refactoring. Simplify LoadCurrentConfig() and convert most " with '.

gclient.py

 #!/usr/bin/python
 # Copyright (c) 2010 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.
 
-"""A wrapper script to manage a set of client modules in different SCM.
-
-This script is intended to be used to help basic management of client
-program sources residing in one or more Subversion modules and Git
-repositories, along with other modules it depends on, also in Subversion or Git,
-but possibly on multiple respositories, making a wrapper system apparently
-necessary.
+"""Meta checkout manager supporting both Subversion and GIT.
 
 Files
   .gclient      : Current client configuration, written by 'config' command.
                   Format is a Python script defining 'solutions', a list whose
                   entries each are maps binding the strings "name" and "url"
                   to strings specifying the name and location of the client
                   module, as well as "custom_deps" to a map similar to the DEPS
                   file below.
   .gclient_entries : A cache constructed by 'update' command.  Format is a
                   Python script defining 'entries', a list of the names
                   of all modules in the client
   <module>/DEPS : Python script defining var 'deps' as a map from each requisite
                   submodule name to a URL where it can be found (via one SCM)
 
 Hooks
   .gclient and DEPS files may optionally contain a list named "hooks" to
   allow custom actions to be performed based on files that have changed in the
   working copy as a result of a "sync"/"update" or "revert" operation.  This
-  could be prevented by using --nohooks (hooks run by default). Hooks can also
+  can be prevented by using --nohooks (hooks run by default). Hooks can also
   be forced to run with the "runhooks" operation.  If "sync" is run with
   --force, all known hooks will run regardless of the state of the working
   copy.
 
   Each item in a "hooks" list is a dict, containing these two keys:
     "pattern"  The associated value is a string containing a regular
                expression.  When a file whose pathname matches the expression
                is checked out, updated, or reverted, the hook's "action" will
                run.
     "action"   A list describing a command to run along with its arguments, if
                any.  An action command will run at most one time per gclient
                invocation, regardless of how many files matched the pattern.
                The action is executed in the same directory as the .gclient
                file.  If the first item in the list is the string "python",
                the current Python interpreter (sys.executable) will be used
                to run the command. If the list contains string "$matching_files"
                it will be removed from the list and the list will be extended
                by the list of matching files.
 
   Example:
     hooks = [
       { "pattern": "\\.(gif|jpe?g|pr0n|png)$",
         "action":  ["python", "image_indexer.py", "--all"]},
     ]
 """
 
-__version__ = "0.4"
+__version__ = "0.4.1"
 
 import errno
 import logging
 import optparse
 import os
 import pprint
 import re
 import sys
 import urlparse
 import urllib
@@ skipping 82 matching lines @@
       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 gclient_utils.Error("Var is not defined: %s" % var_name)
 
 
 class Dependency(GClientKeywords):
   """Object that represents a dependency checkout."""
   DEPS_FILE = 'DEPS'
+
   def __init__(self, parent, name, url, safesync_url=None, custom_deps=None,
-      custom_vars=None, deps_file=None):
+               custom_vars=None, deps_file=None):
     GClientKeywords.__init__(self)
     self.parent = parent
     self.name = name
     self.url = url
     # These 2 are only set in .gclient and not in DEPS files.
     self.safesync_url = safesync_url
     self.custom_vars = custom_vars or {}
     self.custom_deps = custom_deps or {}
+    self.deps_hooks = []
     self.dependencies = []
     self.deps_file = deps_file or self.DEPS_FILE
-    self._deps_hooks = []
 
     # Sanity checks
     if not self.name and self.parent:
       raise gclient_utils.Error('Dependency without name')
     if not isinstance(self.url,
         (basestring, self.FromImpl, self.FileImpl, None.__class__)):
       raise gclient_utils.Error('dependency url must be either a string, None, '
                                 'File() or From() instead of %s' %
                                 self.url.__class__.__name__)
     if '/' in self.deps_file or '\\' in self.deps_file:
@@ skipping 47 matching lines @@
 ]
 """)
 
   def __init__(self, root_dir, options):
     Dependency.__init__(self, None, None, None)
     self._root_dir = root_dir
     self._options = options
     self.config_content = None
 
   def SetConfig(self, content):
+    assert self.dependencies == []
     config_dict = {}
     self.config_content = content
     try:
       exec(content, config_dict)
     except SyntaxError, e:
       try:
         # 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 gclient_utils.Error('\n'.join(error_message))
     for s in config_dict.get('solutions', []):
       self.dependencies.append(Dependency(
           self, s['name'], s['url'],
           s.get('safesync_url', None),
           s.get('custom_deps', {}),
           s.get('custom_vars', {})))
     # .gclient can have hooks.
-    self._deps_hooks = config_dict.get('hooks', [])
+    self.deps_hooks = config_dict.get('hooks', [])
 
   def SaveConfig(self):
     gclient_utils.FileWrite(os.path.join(self.root_dir(),
                                          self._options.config_filename),
                             self.config_content)
 
-  def _LoadConfig(self):
-    client_source = gclient_utils.FileRead(
-        os.path.join(self.root_dir(), self._options.config_filename))
-    self.SetConfig(client_source)
-
   @staticmethod
-  def LoadCurrentConfig(options, from_dir=None):
+  def LoadCurrentConfig(options):
     """Searches for and loads a .gclient file relative to the current working
-    dir.
-
-    Returns:
-      A dict representing the contents of the .gclient file or an empty dict if
-      the .gclient file doesn't exist.
-    """
-    if not from_dir:
-      from_dir = os.curdir
-    path = os.path.realpath(from_dir)
-    while not os.path.exists(os.path.join(path, options.config_filename)):
-      split_path = os.path.split(path)
-      if not split_path[1]:
-        return None
-      path = split_path[0]
+    dir. Returns a GClient object."""
+    path = gclient_utils.FindGclientRoot(os.getcwd(), options.config_filename)
+    if not path:
+      return None
     client = GClient(path, options)
-    client._LoadConfig()
+    client.SetConfig(gclient_utils.FileRead(
+        os.path.join(path, options.config_filename)))
     return client
 
   def SetDefaultConfig(self, solution_name, solution_url, safesync_url):
     self.SetConfig(self.DEFAULT_CLIENT_FILE_TEXT % {
       'solution_name': solution_name,
       'solution_url': solution_url,
       'safesync_url' : safesync_url,
     })
 
   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.
     """
     # Sometimes pprint.pformat will use {', sometimes it'll use { ' ... It
     # makes testing a bit too fun.
     result = pprint.pformat(entries, 2)
     if result.startswith('{\''):
       result = '{ \'' + result[2:]
     text = "entries = \\\n" + result + '\n'
     file_path = os.path.join(self.root_dir(), self._options.entries_filename)
     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(gclient_utils.FileRead(filename), scope)
-    return scope["entries"]
+    return scope['entries']
 
   def _ParseSolutionDeps(self, solution_name, solution_deps_content,
                          custom_vars, parse_hooks):
     """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 36 matching lines @@
           # platform, but this is the best we can do.
           deps.update([x for x in os_deps.items() if not x[0] in deps])
         else:
           deps.update(os_deps)
 
     if 'hooks' in local_scope and parse_hooks:
       # TODO(maruel): Temporary Hack. Since this function is misplaced, find the
       # right 'self' to add the hooks.
       for d in self.dependencies:
         if d.name == solution_name:
-          d._deps_hooks.extend(local_scope['hooks'])
+          d.deps_hooks.extend(local_scope['hooks'])
           break
 
     # If use_relative_paths is set in the DEPS file, regenerate
     # the dictionary using paths relative to the directory containing
     # the DEPS file.
     if local_scope.get('use_relative_paths'):
       rel_deps = {}
       for d, url in deps.items():
         # normpath is required to allow DEPS to use .. in their
         # dependency local path.
@@ skipping 103 matching lines @@
     """
     # Hooks only run for these command types.
     if not command in ('update', 'revert', 'runhooks'):
       return
 
     # Hooks only run when --nohooks is not specified
     if self._options.nohooks:
       return
 
     # Get any hooks from the .gclient file.
-    hooks = self._deps_hooks[:]
+    hooks = self.deps_hooks[:]
     # Add any hooks found in DEPS files.
     for d in self.dependencies:
-      hooks.extend(d._deps_hooks)
+      hooks.extend(d.deps_hooks)
 
     # If "--force" was specified, run all hooks regardless of what files have
     # changed.  If the user is using git, then we don't know what files have
     # 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
@@ skipping 32 matching lines @@
         print >> sys.stderr, ('Please fix your script, having invalid '
                               '--revision flags will soon considered an error.')
       else:
         revision_overrides[sol] = rev
       index += 1
     return revision_overrides
 
   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 gclient_utils.Error("'%s' is an unsupported command" % command)
 
     if not self.dependencies:
       raise gclient_utils.Error("No solution specified")
     revision_overrides = self._EnforceRevisions()
 
     # When running runhooks --force, there's no need to consult the SCM.
     # All known hooks are expected to run unconditionally regardless of working
@@ skipping 235 matching lines @@
 
 
 #### gclient commands.
 
 
 def CMDcleanup(parser, args):
   """Cleans up all working copies.
 
 Mostly svn-specific. Simply runs 'svn cleanup' for each module.
 """
-  parser.add_option("--deps", dest="deps_os", metavar="OS_LIST",
-                    help="override deps for the specified (comma-separated) "
-                         "platform(s); 'all' will process all deps_os "
-                         "references")
+  parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
+                    help='override deps for the specified (comma-separated) '
+                         'platform(s); \'all\' will process all deps_os '
+                         'references')
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
   if not client:
-    raise gclient_utils.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.config_content)
   return client.RunOnDeps('cleanup', args)
 
 
 @attr('usage', '[url] [safesync url]')
 def CMDconfig(parser, args):
   """Create a .gclient file in the current directory.
 
 This specifies the configuration for further commands. After update/sync,
 top-level DEPS files in each module are read to determine dependent
 modules to operate on as well. If optional [url] parameter is
 provided, then configuration is read from a specified Subversion server
 URL.
 """
-  parser.add_option("--spec",
-                    help="create a gclient file containing the provided "
-                         "string. Due to Cygwin/Python brokenness, it "
-                         "probably can't contain any newlines.")
-  parser.add_option("--name",
-                    help="overrides the default name for the solution")
+  parser.add_option('--spec',
+                    help='create a gclient file containing the provided '
+                         'string. Due to Cygwin/Python brokenness, it '
+                         'probably can\'t contain any newlines.')
+  parser.add_option('--name',
+                    help='overrides the default name for the solution')
   (options, args) = parser.parse_args(args)
   if ((options.spec and args) or len(args) > 2 or
       (not options.spec and not args)):
     parser.error('Inconsistent arguments. Use either --spec or one or 2 args')
 
   if os.path.exists(options.config_filename):
-    raise gclient_utils.Error("%s file already exists in the current directory"
+    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:
     base_url = args[0].rstrip('/')
     if not options.name:
-      name = base_url.split("/")[-1]
+      name = base_url.split('/')[-1]
     else:
       # specify an alternate relpath for the given URL.
       name = options.name
-    safesync_url = ""
+    safesync_url = ''
     if len(args) > 1:
       safesync_url = args[1]
     client.SetDefaultConfig(name, base_url, safesync_url)
   client.SaveConfig()
   return 0
 
 
 def CMDexport(parser, args):
   """Wrapper for svn export for all managed directories."""
-  parser.add_option("--deps", dest="deps_os", metavar="OS_LIST",
-                    help="override deps for the specified (comma-separated) "
-                         "platform(s); 'all' will process all deps_os "
-                         "references")
+  parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
+                    help='override deps for the specified (comma-separated) '
+                         'platform(s); \'all\' will process all deps_os '
+                         'references')
   (options, args) = parser.parse_args(args)
   if len(args) != 1:
-    raise gclient_utils.Error("Need directory name")
+    raise gclient_utils.Error('Need directory name')
   client = GClient.LoadCurrentConfig(options)
 
   if not client:
-    raise gclient_utils.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.config_content)
   return client.RunOnDeps('export', args)
 
 
 @attr('epilog', """Example:
   gclient pack > patch.txt
     generate simple patch for configured client and dependences
 """)
 def CMDpack(parser, args):
   """Generate a patch which can be applied at the root of the tree.
 
 Internally, runs 'svn diff'/'git diff' on each checked out module and
 dependencies, and performs minimal postprocessing of the output. The
 resulting patch is printed to stdout and can be applied to a freshly
 checked out tree via 'patch -p0 < patchfile'.
 """
-  parser.add_option("--deps", dest="deps_os", metavar="OS_LIST",
-                    help="override deps for the specified (comma-separated) "
-                         "platform(s); 'all' will process all deps_os "
-                         "references")
+  parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
+                    help='override deps for the specified (comma-separated) '
+                         'platform(s); \'all\' will process all deps_os '
+                         'references')
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
   if not client:
-    raise gclient_utils.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.config_content)
   return client.RunOnDeps('pack', args)
 
 
 def CMDstatus(parser, args):
   """Show modification status for every dependencies."""
-  parser.add_option("--deps", dest="deps_os", metavar="OS_LIST",
-                    help="override deps for the specified (comma-separated) "
-                         "platform(s); 'all' will process all deps_os "
-                         "references")
+  parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
+                    help='override deps for the specified (comma-separated) '
+                         'platform(s); \'all\' will process all deps_os '
+                         'references')
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
   if not client:
-    raise gclient_utils.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.config_content)
   return client.RunOnDeps('status', args)
 
 
 @attr('epilog', """Examples:
   gclient sync
       update files from SCM according to current configuration,
       *for modules which have changed since last update or sync*
   gclient sync --force
       update files from SCM according to current configuration, for
       all modules (useful for recovering files deleted from local copy)
   gclient sync --revision src@31000
       update src directory to r31000
 """)
 def CMDsync(parser, args):
   """Checkout/update all modules."""
-  parser.add_option("-f", "--force", action="store_true",
-                    help="force update even for unchanged modules")
-  parser.add_option("-n", "--nohooks", action="store_true",
-                    help="don't run hooks after the update is complete")
-  parser.add_option("-r", "--revision", action="append",
-                    dest="revisions", metavar="REV", default=[],
-                    help="Enforces revision/hash for the solutions with the "
-                         "format src@rev. The src@ part is optional and can be "
-                         "skipped. -r can be used multiple times when .gclient "
-                         "has multiple solutions configured and will work even "
-                         "if the src@ part is skipped.")
-  parser.add_option("-H", "--head", action="store_true",
-                    help="skips any safesync_urls specified in "
-                         "configured solutions and sync to head instead")
-  parser.add_option("-D", "--delete_unversioned_trees", action="store_true",
-                    help="delete any unexpected unversioned trees "
-                         "that are in the checkout")
-  parser.add_option("-R", "--reset", action="store_true",
-                    help="resets any local changes before updating (git only)")
-  parser.add_option("--deps", dest="deps_os", metavar="OS_LIST",
-                    help="override deps for the specified (comma-separated) "
-                         "platform(s); 'all' will process all deps_os "
-                         "references")
-  parser.add_option("-m", "--manually_grab_svn_rev", action="store_true",
-                    help="Skip svn up whenever possible by requesting "
-                         "actual HEAD revision from the repository")
+  parser.add_option('-f', '--force', action='store_true',
+                    help='force update even for unchanged modules')
+  parser.add_option('-n', '--nohooks', action='store_true',
+                    help='don\'t run hooks after the update is complete')
+  parser.add_option('-r', '--revision', action='append',
+                    dest='revisions', metavar='REV', default=[],
+                    help='Enforces revision/hash for the solutions with the '
+                         'format src@rev. The src@ part is optional and can be '
+                         'skipped. -r can be used multiple times when .gclient '
+                         'has multiple solutions configured and will work even '
+                         'if the src@ part is skipped.')
+  parser.add_option('-H', '--head', action='store_true',
+                    help='skips any safesync_urls specified in '
+                         'configured solutions and sync to head instead')
+  parser.add_option('-D', '--delete_unversioned_trees', action='store_true',
+                    help='delete any unexpected unversioned trees '
+                         'that are in the checkout')
+  parser.add_option('-R', '--reset', action='store_true',
+                    help='resets any local changes before updating (git only)')
+  parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
+                    help='override deps for the specified (comma-separated) '
+                         'platform(s); \'all\' will process all deps_os '
+                         'references')
+  parser.add_option('-m', '--manually_grab_svn_rev', action='store_true',
+                    help='Skip svn up whenever possible by requesting '
+                         'actual HEAD revision from the repository')
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
 
   if not client:
-    raise gclient_utils.Error("client not configured; see 'gclient config'")
+    raise gclient_utils.Error('client not configured; see \'gclient config\'')
 
   if options.revisions and options.head:
     # TODO(maruel): Make it a parser.error if it doesn't break any builder.
-    print("Warning: you cannot use both --head and --revision")
+    print('Warning: you cannot use both --head and --revision')
 
   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.config_content)
   return client.RunOnDeps('update', args)
 
 
 def CMDupdate(parser, args):
   """Alias for the sync command. Deprecated."""
   return CMDsync(parser, args)
 
 def CMDdiff(parser, args):
   """Displays local diff for every dependencies."""
-  parser.add_option("--deps", dest="deps_os", metavar="OS_LIST",
-                    help="override deps for the specified (comma-separated) "
-                         "platform(s); 'all' will process all deps_os "
-                         "references")
+  parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
+                    help='override deps for the specified (comma-separated) '
+                         'platform(s); \'all\' will process all deps_os '
+                         'references')
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
   if not client:
-    raise gclient_utils.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.config_content)
   return client.RunOnDeps('diff', args)
 
 
 def CMDrevert(parser, args):
   """Revert all modifications in every dependencies."""
-  parser.add_option("--deps", dest="deps_os", metavar="OS_LIST",
-                    help="override deps for the specified (comma-separated) "
-                         "platform(s); 'all' will process all deps_os "
-                         "references")
-  parser.add_option("-n", "--nohooks", action="store_true",
-                    help="don't run hooks after the revert is complete")
+  parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
+                    help='override deps for the specified (comma-separated) '
+                         'platform(s); \'all\' will process all deps_os '
+                         'references')
+  parser.add_option('-n', '--nohooks', action='store_true',
+                    help='don\'t run hooks after the revert is complete')
   (options, args) = parser.parse_args(args)
   # --force is implied.
   options.force = True
   client = GClient.LoadCurrentConfig(options)
   if not client:
-    raise gclient_utils.Error("client not configured; see 'gclient config'")
+    raise gclient_utils.Error('client not configured; see \'gclient config\'')
   return client.RunOnDeps('revert', args)
 
 
 def CMDrunhooks(parser, args):
   """Runs hooks for files that have been modified in the local working copy."""
-  parser.add_option("--deps", dest="deps_os", metavar="OS_LIST",
-                    help="override deps for the specified (comma-separated) "
-                         "platform(s); 'all' will process all deps_os "
-                         "references")
-  parser.add_option("-f", "--force", action="store_true", default=True,
-                    help="Deprecated. No effect.")
+  parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
+                    help='override deps for the specified (comma-separated) '
+                         'platform(s); \'all\' will process all deps_os '
+                         'references')
+  parser.add_option('-f', '--force', action='store_true', default=True,
+                    help='Deprecated. No effect.')
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
   if not client:
-    raise gclient_utils.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.config_content)
   options.force = True
   options.nohooks = False
   return client.RunOnDeps('runhooks', args)
 
 
 def CMDrevinfo(parser, args):
   """Output revision info mapping for the client and its dependencies.
 
-  This allows the capture of an overall "revision" for the source tree that
+  This allows the capture of an overall 'revision' for the source tree that
   can be used to reproduce the same tree in the future. It is only useful for
-  "unpinned dependencies", i.e. DEPS/deps references without a svn revision
-  number or a git hash. A git branch name isn't "pinned" since the actual
+  'unpinned dependencies', i.e. DEPS/deps references without a svn revision
+  number or a git hash. A git branch name isn't 'pinned' since the actual
   commit can change.
   """
   parser.add_option('--deps', dest='deps_os', metavar='OS_LIST',
                     help='override deps for the specified (comma-separated) '
                          'platform(s); \'all\' will process all deps_os '
                          'references')
   parser.add_option('-s', '--snapshot', action='store_true',
                     help='creates a snapshot .gclient file of the current '
                          'version of all repositories to reproduce the tree, '
                          'implies -a')
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
   if not client:
-    raise gclient_utils.Error("client not configured; see 'gclient config'")
+    raise gclient_utils.Error('client not configured; see \'gclient config\'')
   client.PrintRevInfo()
   return 0
 
 
 def Command(name):
   return getattr(sys.modules[__name__], 'CMD' + name, None)
 
 
 def CMDhelp(parser, args):
   """Prints list of commands or help for a specific command."""
@@ skipping 67 matching lines @@
     return CMDhelp(parser, argv)
   except gclient_utils.Error, e:
     print >> sys.stderr, 'Error: %s' % str(e)
     return 1
 
 
 if '__main__' == __name__:
   sys.exit(Main(sys.argv[1:]))
 
 # vim: ts=2:sw=2:tw=80:et: