Some preparation work towards the gclient.py refactor.

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,
@@ skipping 67 matching lines @@
   """Sets an attribute on a function."""
   def hook(fn):
     setattr(fn, attr, data)
     return fn
   return hook
 
 
 ## GClient implementation.
 
 
-class GClient(object):
+class GClientKeywords(object):
+  class FromImpl(object):
+    """Used to implement the From() syntax."""
+
+    def __init__(self, module_name, sub_target_name=None):
+      """module_name is the dep module we want to include from.  It can also be
+      the name of a subdirectory to include from.
+
+      sub_target_name is an optional parameter if the module name in the other
+      DEPS file is different. E.g., you might want to map src/net to net."""
+      self.module_name = module_name
+      self.sub_target_name = sub_target_name
+
+    def __str__(self):
+      return 'From(%s, %s)' % (repr(self.module_name),
+                               repr(self.sub_target_name))
+
+    def GetUrl(self, target_name, sub_deps_base_url, root_dir, sub_deps):
+      """Resolve the URL for this From entry."""
+      sub_deps_target_name = target_name
+      if self.sub_target_name:
+        sub_deps_target_name = self.sub_target_name
+      url = sub_deps[sub_deps_target_name]
+      if url.startswith('/'):
+        # If it's a relative URL, we need to resolve the URL relative to the
+        # sub deps base URL.
+        if not isinstance(sub_deps_base_url, basestring):
+          sub_deps_base_url = sub_deps_base_url.GetPath()
+        scm = gclient_scm.CreateSCM(sub_deps_base_url, root_dir,
+                                    None)
+        url = scm.FullUrlForRelativeUrl(url)
+      return url
+
+  class FileImpl(object):
+    """Used to implement the File('') syntax which lets you sync a single file
+    from an SVN repo."""
+
+    def __init__(self, file_location):
+      self.file_location = file_location
+
+    def __str__(self):
+      return 'File("%s")' % self.file_location
+
+    def GetPath(self):
+      return os.path.split(self.file_location)[0]
+
+    def GetFilename(self):
+      rev_tokens = self.file_location.split('@')
+      return os.path.split(rev_tokens[0])[1]
+
+    def GetRevision(self):
+      rev_tokens = self.file_location.split('@')
+      if len(rev_tokens) > 1:
+        return rev_tokens[1]
+      return None
+
+  class VarImpl(object):
+    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 gclient_utils.Error("Var is not defined: %s" % var_name)
+
+
+class GClient(GClientKeywords):
   """Object that represent a gclient checkout."""
 
-  supported_commands = [
+  SUPPORTED_COMMANDS = [
     'cleanup', 'diff', 'export', 'pack', 'revert', 'status', 'update',
     'runhooks'
   ]
 
-  deps_os_choices = {
+  DEPS_OS_CHOICES = {
     "win32": "win",
     "win": "win",
     "cygwin": "win",
     "darwin": "mac",
     "mac": "mac",
     "unix": "unix",
     "linux": "unix",
     "linux2": "unix",
   }
 
@@ skipping 23 matching lines @@
   DEFAULT_SNAPSHOT_FILE_TEXT = ("""\
 # Snapshot generated with gclient revinfo --snapshot
 solutions = [
 %(solution_list)s
 ]
 """)
 
   def __init__(self, root_dir, options):
     self._root_dir = root_dir
     self._options = options
-    self._config_content = None
+    self.config_content = None
     self._config_dict = {}
     self._deps_hooks = []
 
   def SetConfig(self, content):
     self._config_dict = {}
-    self._config_content = content
+    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 gclient_utils.Error('\n'.join(error_message))
 
   def SaveConfig(self):
     gclient_utils.FileWrite(os.path.join(self._root_dir,
                                          self._options.config_filename),
-                            self._config_content)
+                            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)
 
-  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):
     """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
@@ skipping 45 matching lines @@
       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"]
 
-  class FromImpl:
-    """Used to implement the From syntax."""
-
-    def __init__(self, module_name, sub_target_name=None):
-      """module_name is the dep module we want to include from.  It can also be
-      the name of a subdirectory to include from.
-
-      sub_target_name is an optional parameter if the module name in the other
-      DEPS file is different. E.g., you might want to map src/net to net."""
-      self.module_name = module_name
-      self.sub_target_name = sub_target_name
-
-    def __str__(self):
-      return 'From(%s, %s)' % (repr(self.module_name),
-                               repr(self.sub_target_name))
-
-    def GetUrl(self, target_name, sub_deps_base_url, root_dir, sub_deps):
-      """Resolve the URL for this From entry."""
-      sub_deps_target_name = target_name
-      if self.sub_target_name:
-        sub_deps_target_name = self.sub_target_name
-      url = sub_deps[sub_deps_target_name]
-      if url.startswith('/'):
-        # If it's a relative URL, we need to resolve the URL relative to the
-        # sub deps base URL.
-        if not isinstance(sub_deps_base_url, basestring):
-          sub_deps_base_url = sub_deps_base_url.GetPath()
-        scm = gclient_scm.CreateSCM(sub_deps_base_url, root_dir,
-                                    None)
-        url = scm.FullUrlForRelativeUrl(url)
-      return url
-
-  class FileImpl:
-    """Used to implement the File('') syntax which lets you sync a single file
-    from an SVN repo."""
-
-    def __init__(self, file_location):
-      self.file_location = file_location
-
-    def __str__(self):
-      return 'File("%s")' % self.file_location
-
-    def GetPath(self):
-      return os.path.split(self.file_location)[0]
-
-    def GetFilename(self):
-      rev_tokens = self.file_location.split('@')
-      return os.path.split(rev_tokens[0])[1]
-
-    def GetRevision(self):
-      rev_tokens = self.file_location.split('@')
-      if len(rev_tokens) > 1:
-        return rev_tokens[1]
-      return None
-
-  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 gclient_utils.Error("Var is not defined: %s" % var_name)
-
   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.
 
     Returns:
       A dict mapping module names (as relative paths) to URLs or an empty
       dict if the solution does not have a DEPS file.
     """
     # Skip empty
     if not solution_deps_content:
       return {}
     # Eval the content
     local_scope = {}
-    var = self._VarImpl(custom_vars, local_scope)
+    var = self.VarImpl(custom_vars, local_scope)
     global_scope = {
       "File": self.FileImpl,
       "From": self.FromImpl,
       "Var": var.Lookup,
       "deps_os": {},
     }
     exec(solution_deps_content, global_scope, local_scope)
     deps = local_scope.get("deps", {})
 
     # load os specific dependencies if defined.  these dependencies may
     # override or extend the values defined by the 'deps' member.
     if "deps_os" in local_scope:
       if self._options.deps_os is not None:
         deps_to_include = self._options.deps_os.split(",")
         if "all" in deps_to_include:
-          deps_to_include = list(set(self.deps_os_choices.itervalues()))
+          deps_to_include = list(set(self.DEPS_OS_CHOICES.itervalues()))
       else:
-        deps_to_include = [self.deps_os_choices.get(sys.platform, "unix")]
+        deps_to_include = [self.DEPS_OS_CHOICES.get(sys.platform, "unix")]
 
       deps_to_include = set(deps_to_include)
       for deps_os_key in deps_to_include:
         os_deps = local_scope["deps_os"].get(deps_os_key, {})
         if len(deps_to_include) > 1:
           # Ignore any overrides when including deps for more than one
           # platform, so we collect the broadest set of dependencies available.
           # We may end up with the wrong revision of something for our
           # platform, but this is the best we can do.
           deps.update([x for x in os_deps.items() if not x[0] in deps])
@@ skipping 183 matching lines @@
 
     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:
+    if not command in self.SUPPORTED_COMMANDS:
       raise gclient_utils.Error("'%s' is an unsupported command" % command)
 
     solutions = self.GetVar("solutions")
     if not solutions:
       raise gclient_utils.Error("No solution specified")
     revision_overrides = self._EnforceRevisions(solutions)
 
     # 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.
@@ skipping 225 matching lines @@
                      }
     else:
       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)
+      print(snapclient.config_content)
 
 
 #### 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")
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
   if not client:
     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())
+    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
@@ skipping 42 matching lines @@
   if len(args) != 1:
     raise gclient_utils.Error("Need directory name")
   client = GClient.LoadCurrentConfig(options)
 
   if not client:
     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())
+    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")
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
   if not client:
     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())
+    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")
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
   if not client:
     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())
+    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)
@@ skipping 34 matching lines @@
   if not client:
     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")
 
   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())
+    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")
   (options, args) = parser.parse_args(args)
   client = GClient.LoadCurrentConfig(options)
   if not client:
     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())
+    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",
@@ skipping 15 matching lines @@
                          "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'")
   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())
+    print(client.config_content)
   options.force = True
   options.nohooks = False
   return client.RunOnDeps('runhooks', args)
 
 
 def CMDrevinfo(parser, args):
   """Outputs details 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 "
@@ skipping 79 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: