Mixed bag of nits.

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.
 
 """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
@@ skipping 384 matching lines @@
       out.append('')
     return '\n'.join(out)
 
   def __repr__(self):
     return '%s: %s' % (self.name, self.url)
 
 
 class GClient(Dependency):
   """Object that represent a gclient checkout. A tree of Dependency(), one per
   solution or DEPS entry."""
-  SUPPORTED_COMMANDS = [
-    'cleanup', 'diff', 'export', 'pack', 'revert', 'status', 'update',
-    'runhooks'
-  ]
 
   DEPS_OS_CHOICES = {
     "win32": "win",
     "win": "win",
     "cygwin": "win",
     "darwin": "mac",
     "mac": "mac",
     "unix": "unix",
     "linux": "unix",
     "linux2": "unix",
   }
 
   DEFAULT_CLIENT_FILE_TEXT = ("""\
 solutions = [
   { "name"        : "%(solution_name)s",
     "url"         : "%(solution_url)s",
     "custom_deps" : {
     },
-    "safesync_url": "%(safesync_url)s"
+    "safesync_url": "%(safesync_url)s",
   },
 ]
 """)
 
   DEFAULT_SNAPSHOT_SOLUTION_TEXT = ("""\
   { "name"        : "%(solution_name)s",
     "url"         : "%(solution_url)s",
     "custom_deps" : {
-      %(solution_deps)s,
-    },
-    "safesync_url": "%(safesync_url)s"
+%(solution_deps)s    },
+    "safesync_url": "%(safesync_url)s",
   },
 """)
 
   DEFAULT_SNAPSHOT_FILE_TEXT = ("""\
 # Snapshot generated with gclient revinfo --snapshot
 solutions = [
-%(solution_list)s
-]
+%(solution_list)s]
 """)
 
   def __init__(self, root_dir, options):
     Dependency.__init__(self, None, None, None)
     self._options = options
     if options.deps_os:
       enforced_os = options.deps_os.split(',')
     else:
       enforced_os = [self.DEPS_OS_CHOICES.get(sys.platform, 'unix')]
     if 'all' in enforced_os:
@@ skipping 58 matching lines @@
     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'
+    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.
 
     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 []
+      return {}
     exec(gclient_utils.FileRead(filename), scope)
     return scope['entries']
 
   def _EnforceRevisions(self):
     """Checks for revision overrides."""
     revision_overrides = {}
     if self._options.head:
       return revision_overrides
     for s in self.dependencies:
       if not s.safesync_url:
@@ skipping 22 matching lines @@
       index += 1
     return revision_overrides
 
   def RunOnDeps(self, command, args):
     """Runs a command on each dependency in a client and its dependencies.
 
     Args:
       command: The command to use (e.g., 'status' or 'diff')
       args: list of str - extra arguments to add to the command line.
     """
-    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")
+      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
     # copy state, so skip the SCM status check.
     run_scm = not (command == 'runhooks' and self._options.force)
 
     entries = {}
     file_list = []
     # Run on the base solutions first.
@@ skipping 98 matching lines @@
             scm.status(self._options, [], file_list)
             modified_files = file_list != []
           if not self._options.delete_unversioned_trees or modified_files:
             # There are modified files in this entry. Keep warning until
             # removed.
             print(('\nWARNING: \'%s\' is no longer part of this client.  '
                    'It is recommended that you manually remove it.\n') %
                       entry_fixed)
           else:
             # Delete the entry
-            print('\n________ deleting \'%s\' ' +
-                  'in \'%s\'') % (entry_fixed, self.root_dir())
+            print('\n________ deleting \'%s\' in \'%s\'' % (
+                entry_fixed, self.root_dir()))
             gclient_utils.RemoveDirectory(e_dir)
       # record the current list of entries for next time
       self._SaveEntries(entries)
     return 0
 
   def PrintRevInfo(self):
     """Output revision info mapping for the client and its dependencies.
 
     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
     commit can change.
 
     The --snapshot option allows creating a .gclient file to reproduce the tree.
     """
     if not self.dependencies:
-      raise gclient_utils.Error("No solution specified")
+      raise gclient_utils.Error('No solution specified')
 
     # Inner helper to generate base url and rev tuple
     def GetURLAndRev(name, original_url):
       url, _ = gclient_utils.SplitUrlRevision(original_url)
       scm = gclient_scm.CreateSCM(original_url, self.root_dir(), name)
       return (url, scm.revinfo(self._options, [], None))
 
     # text of the snapshot gclient file
     new_gclient = ""
     # Dictionary of { path : SCM url } to ensure no duplicate solutions
@@ skipping 31 matching lines @@
         sub_deps_base_url = deps[deps[d].module_name]
         sub_deps = Dependency(self, deps[d].module_name, sub_deps_base_url
             ).ParseDepsFile(False)
         url = deps[d].GetUrl(d, sub_deps_base_url, self.root_dir(), sub_deps)
         (url, rev) = GetURLAndRev(d, url)
         entries[d] = "%s@%s" % (url, rev)
 
     # Build the snapshot configuration string
     if self._options.snapshot:
       url = entries.pop(name)
-      custom_deps = ",\n      ".join(["\"%s\": \"%s\"" % (x, entries[x])
-                                      for x in sorted(entries.keys())])
+      custom_deps = ''.join(['      \"%s\": \"%s\",\n' % (x, entries[x])
+                             for x in sorted(entries.keys())])
 
       new_gclient += self.DEFAULT_SNAPSHOT_SOLUTION_TEXT % {
                      'solution_name': name,
                      'solution_url': url,
-                     'safesync_url' : "",
+                     'safesync_url' : '',
                      'solution_deps': custom_deps,
                      }
     else:
-      print(";\n".join(["%s: %s" % (x, entries[x])
+      print(';\n'.join(['%s: %s' % (x, entries[x])
                        for x in sorted(entries.keys())]))
 
     # Print the snapshot configuration file
     if self._options.snapshot:
       config = self.DEFAULT_SNAPSHOT_FILE_TEXT % {'solution_list': new_gclient}
       snapclient = GClient(self.root_dir(), self._options)
       snapclient.SetConfig(config)
       print(snapclient.config_content)
 
   def ParseDepsFile(self, direct_reference):
@@ skipping 372 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: