Bring some OOP and sanity to gclient.py.

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 31 matching lines @@
                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.1"
+__version__ = "0.5"
 
-import errno
 import logging
 import optparse
 import os
 import pprint
 import re
 import sys
 import urlparse
 import urllib
 
 import breakpad
@@ skipping 24 matching lines @@
 
       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
 
@@ skipping 27 matching lines @@
 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):
     GClientKeywords.__init__(self)
     self.parent = parent
     self.name = name
     self.url = url
+    self.parsed_url = None
     # 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
+    # A cache of the files affected by the current operation, necessary for
+    # hooks.
+    self.file_list = []
     self.deps_parsed = False
     self.direct_reference = False
 
     # Sanity checks
     if not self.name and self.parent:
       raise gclient_utils.Error('Dependency without name')
+    if self.name in [d.name for d in self.tree(False)]:
+      raise gclient_utils.Error('Dependency %s specified more than once' %
+          self.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:
       raise gclient_utils.Error('deps_file name must not be a path, just a '
                                 'filename. %s' % self.deps_file)
 
+  def LateOverride(self, url):
+    overriden_url = self.get_custom_deps(self.name, url)
+    if overriden_url != url:
+      self.parsed_url = overriden_url
+      logging.debug('%s, %s was overriden to %s' % (self.name, url,
+          self.parsed_url))
+    elif isinstance(url, self.FromImpl):
+      ref = [dep for dep in self.tree(True) if url.module_name == dep.name]
+      if not len(ref) == 1:
+        raise Exception('Failed to find one reference to %s. %s' % (
+          url.module_name, ref))
+      ref = ref[0]
+      sub_target = url.sub_target_name or url
+      # Make sure the referenced dependency DEPS file is loaded and file the
+      # inner referenced dependency.
+      ref.ParseDepsFile(False)
+      found_dep = None
+      for d in ref.dependencies:
+        if d.name == sub_target:
+          found_dep = d
+          break
+      if not found_dep:
+        raise Exception('Couldn\'t find %s in %s, referenced by %s' % (
+            sub_target, ref.name, self.name))
+      # Call LateOverride() again.
+      self.parsed_url = found_dep.LateOverride(found_dep.url)
+      logging.debug('%s, %s to %s' % (self.name, url, self.parsed_url))
+    elif isinstance(url, basestring):
+      parsed_url = urlparse.urlparse(url)
+      if not parsed_url[0]:
+        # A relative url. Fetch the real base.
+        path = parsed_url[2]
+        if not path.startswith('/'):
+          raise gclient_utils.Error(
+              'relative DEPS entry \'%s\' must begin with a slash' % url)
+        # Create a scm just to query the full url.
+        scm = gclient_scm.CreateSCM(self.parent.parsed_url, self.root_dir(),
+                                    None)
+        self.parsed_url = scm.FullUrlForRelativeUrl(url)
+      else:
+        self.parsed_url = url
+      logging.debug('%s, %s -> %s' % (self.name, url, self.parsed_url))
+    elif isinstance(url, self.FileImpl):
+      self.parsed_url = url
+      logging.debug('%s, %s -> %s (File)' % (self.name, url, self.parsed_url))
+    return self.parsed_url
+
   def ParseDepsFile(self, direct_reference):
     """Parses the DEPS file for this dependency."""
     if direct_reference:
       # Maybe it was referenced earlier by a From() keyword but it's now
       # directly referenced.
       self.direct_reference = direct_reference
+    if self.deps_parsed:
+      return
     self.deps_parsed = True
     filepath = os.path.join(self.root_dir(), self.name, self.deps_file)
     if not os.path.isfile(filepath):
-      return {}
+      return
     deps_content = gclient_utils.FileRead(filepath)
 
     # Eval the content.
     # One thing is unintuitive, vars= {} must happen before Var() use.
     local_scope = {}
     var = self.VarImpl(self.custom_vars, local_scope)
     global_scope = {
       'File': self.FileImpl,
       'From': self.FromImpl,
       'Var': var.Lookup,
@@ skipping 27 matching lines @@
     # the dictionary using paths relative to the directory containing
     # the DEPS file.
     use_relative_paths = local_scope.get('use_relative_paths', False)
     if use_relative_paths:
       rel_deps = {}
       for d, url in deps.items():
         # normpath is required to allow DEPS to use .. in their
         # dependency local path.
         rel_deps[os.path.normpath(os.path.join(self.name, d))] = url
       deps = rel_deps
-    # TODO(maruel): Add these dependencies into self.dependencies.
-    return deps
 
-  def _ParseAllDeps(self, solution_urls):
-    """Parse the complete list of dependencies for the client.
+    # Convert the deps into real Dependency.
+    for name, url in deps.iteritems():
+      if name in [s.name for s in self.dependencies]:
+        raise
+      self.dependencies.append(Dependency(self, name, url))
+    # Sort by name.
+    self.dependencies.sort(key=lambda x: x.name)
+    logging.info('Loaded: %s' % str(self))
 
-    Args:
-      solution_urls: A dict mapping module names (as relative paths) to URLs
-        corresponding to the solutions specified by the client.  This parameter
-        is passed as an optimization.
+  def RunCommandRecursively(self, options, revision_overrides,
+                            command, args, pm):
+    """Runs 'command' before parsing the DEPS in case it's a initial checkout
+    or a revert."""
+    assert self.file_list == []
+    # When running runhooks, 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 = command not in ('runhooks', None)
+    self.LateOverride(self.url)
+    if run_scm and self.parsed_url:
+      if isinstance(self.parsed_url, self.FileImpl):
+        # Special support for single-file checkout.
+        options.revision = self.parsed_url.GetRevision()
+        scm = gclient_scm.CreateSCM(self.parsed_url.GetPath(), self.root_dir(),
+                                    self.name)
+        scm.RunCommand("updatesingle", options,
+                        args + [self.parsed_url.GetFilename()], self.file_list)
+      else:
+        options.revision = revision_overrides.get(self.name)
+        scm = gclient_scm.CreateSCM(self.parsed_url, self.root_dir(), self.name)
+        scm.RunCommand(command, options, args, self.file_list)
+        self.file_list = [os.path.join(self.name, f.strip())
+                          for f in self.file_list]
+      options.revision = None
+    if pm:
+      # The + 1 comes from the fact that .gclient is considered a step in
+      # itself, .i.e. this code is called one time for the .gclient. This is not
+      # conceptually correct but it simplifies code.
+      pm._total = len(self.tree(False)) + 1
+      pm.update()
+    if self.recursion_limit():
+      # Then we can parse the DEPS file.
+      self.ParseDepsFile(True)
+      if pm:
+        pm._total = len(self.tree(False)) + 1
+        pm.update(0)
+      # Parse the dependencies of this dependency.
+      for s in self.dependencies:
+        # TODO(maruel): All these can run concurrently! No need for threads,
+        # just buffer stdout&stderr on pipes and flush as they complete.
+        # Watch out for stdin.
+        s.RunCommandRecursively(options, revision_overrides, command, args, pm)
 
-    Returns:
-      A dict mapping module names (as relative paths) to URLs corresponding
-      to the entire set of dependencies to checkout for the given client.
+  def RunHooksRecursively(self, options):
+    """Evaluates all hooks, running actions as needed. RunCommandRecursively()
+    must have been called before to load the DEPS."""
+    # If "--force" was specified, run all hooks regardless of what files have
+    # changed.
+    if self.deps_hooks:
+      # TODO(maruel): If the user is using git or git-svn, then we don't know
+      # what files have changed so we always run all hooks. It'd be nice to fix
+      # that.
+      if (options.force or
+          gclient_scm.GetScmName(self.parsed_url) in ('git', None) or
+          os.path.isdir(os.path.join(self.root_dir(), self.name, '.git'))):
+        for hook_dict in self.deps_hooks:
+          self._RunHookAction(hook_dict, [])
+      else:
+        # TODO(phajdan.jr): We should know exactly when the paths are absolute.
+        # Convert all absolute paths to relative.
+        for i in range(len(self.file_list)):
+          # It depends on the command being executed (like runhooks vs sync).
+          if not os.path.isabs(self.file_list[i]):
+            continue
 
-    Raises:
-      Error: If a dependency conflicts with another dependency or of a solution.
-    """
-    deps = {}
-    for solution in self.dependencies:
-      solution_deps = solution.ParseDepsFile(True)
+          prefix = os.path.commonprefix([self.root_dir().lower(),
+                                        self.file_list[i].lower()])
+          self.file_list[i] = self.file_list[i][len(prefix):]
 
-      # If a line is in custom_deps, but not in the solution, we want to append
-      # this line to the solution.
-      for d in solution.custom_deps:
-        if d not in solution_deps:
-          solution_deps[d] = solution.custom_deps[d]
+          # Strip any leading path separators.
+          while self.file_list[i][0] in ('\\', '/'):
+            self.file_list[i] = self.file_list[i][1:]
 
-      for d in solution_deps:
-        if d in solution.custom_deps:
-          # Dependency is overriden.
-          url = solution.custom_deps[d]
-          if url is None:
-            continue
-        else:
-          url = solution_deps[d]
-          # if we have a From reference dependent on another solution, then
-          # just skip the From reference. When we pull deps for the solution,
-          # we will take care of this dependency.
-          #
-          # If multiple solutions all have the same From reference, then we
-          # should only add one to our list of dependencies.
-          if isinstance(url, self.FromImpl):
-            if url.module_name in solution_urls:
-              # Already parsed.
-              continue
-            if d in deps and type(deps[d]) != str:
-              if url.module_name == deps[d].module_name:
-                continue
-          elif isinstance(url, str):
-            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 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 gclient_utils.Error(
-              "Solutions have conflicting versions of dependency \"%s\"" % d)
-        if d in solution_urls and solution_urls[d] != url:
-          raise gclient_utils.Error(
-              "Dependency \"%s\" conflicts with specified solution" % d)
-        # Grab the dependency.
-        deps[d] = url
-    return deps
+        # Run hooks on the basis of whether the files from the gclient operation
+        # match each hook's pattern.
+        for hook_dict in self.deps_hooks:
+          pattern = re.compile(hook_dict['pattern'])
+          matching_file_list = [f for f in self.file_list if pattern.search(f)]
+          if matching_file_list:
+            self._RunHookAction(hook_dict, matching_file_list)
+    if self.recursion_limit():
+      for s in self.dependencies:
+        s.RunHooksRecursively(options)
 
   def _RunHookAction(self, hook_dict, matching_file_list):
     """Runs the action from a single hook."""
     logging.info(hook_dict)
     logging.info(matching_file_list)
     command = hook_dict['action'][:]
     if command[0] == 'python':
       # If the hook specified "python" as the first item, the action is a
       # Python script.  Run it by starting a new copy of the same
       # interpreter.
       command[0] = sys.executable
 
     if '$matching_files' in command:
       splice_index = command.index('$matching_files')
       command[splice_index:splice_index + 1] = matching_file_list
 
     # Use a discrete exit status code of 2 to indicate that a hook action
     # failed.  Users of this script may wish to treat hook action failures
     # differently from VC failures.
     return gclient_utils.SubprocessCall(command, self.root_dir(), fail_status=2)
 
-  def _RunHooks(self, command, file_list, is_using_git):
-    """Evaluates all hooks, running actions as needed.
-    """
-    # 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[:]
-    # Add any hooks found in DEPS files.
-    for d in self.dependencies:
-      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
-    # match each hook's pattern.
-    for hook_dict in hooks:
-      pattern = re.compile(hook_dict['pattern'])
-      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 root_dir(self):
     return self.parent.root_dir()
 
   def enforced_os(self):
     return self.parent.enforced_os()
 
   def recursion_limit(self):
     return self.parent.recursion_limit() - 1
 
   def tree(self, force_all):
     return self.parent.tree(force_all)
 
   def get_custom_deps(self, name, url):
     """Returns a custom deps if applicable."""
     if self.parent:
       url = self.parent.get_custom_deps(name, url)
     # None is a valid return value to disable a dependency.
     return self.custom_deps.get(name, url)
 
   def __str__(self):
     out = []
     for i in ('name', 'url', 'safesync_url', 'custom_deps', 'custom_vars',
-              'deps_hooks'):
+              'deps_hooks', 'file_list'):
       # 'deps_file'
       if self.__dict__[i]:
         out.append('%s: %s' % (i, self.__dict__[i]))
 
     for d in self.dependencies:
       out.extend(['  ' + x for x in str(d).splitlines()])
       out.append('')
     return '\n'.join(out)
 
   def __repr__(self):
@@ skipping 106 matching lines @@
         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):
+  def _SaveEntries(self):
     """Creates a .gclient_entries file to record the list of unique checkouts.
 
     The .gclient_entries file lives in the same directory as .gclient.
     """
     # Sometimes pprint.pformat will use {', sometimes it'll use { ' ... It
     # makes testing a bit too fun.
+    entries = dict([(i.name, i.parsed_url) for i in self.tree(False)])
     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.
 
@@ skipping 43 matching lines @@
   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 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
-    # 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.
-    for solution in self.dependencies:
-      name = solution.name
-      if name in entries:
-        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, f.strip()) for f in file_list]
-        self._options.revision = None
-
-    # Process the dependencies next (sort alphanumerically to ensure that
-    # containing directories get populated first and for readability)
-    deps = self._ParseAllDeps(entries)
-    deps_to_process = deps.keys()
-    deps_to_process.sort()
-
-    # First pass for direct dependencies.
+    pm = None
     if command == 'update' and not self._options.verbose:
-      pm = Progress('Syncing projects', len(deps_to_process))
-    for d in deps_to_process:
-      if command == 'update' and not self._options.verbose:
-        pm.update()
-      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
-      elif isinstance(deps[d], self.FileImpl):
-        file_dep = deps[d]
-        self._options.revision = file_dep.GetRevision()
-        if run_scm:
-          scm = gclient_scm.CreateSCM(file_dep.GetPath(), self.root_dir(), d)
-          scm.RunCommand("updatesingle", self._options,
-                         args + [file_dep.GetFilename()], file_list)
-
-    if command == 'update' and not self._options.verbose:
+      pm = Progress('Syncing projects', len(self.tree(False)) + 1)
+    self.RunCommandRecursively(self._options, revision_overrides,
+                               command, args, pm)
+    if pm:
       pm.end()
 
-    # Second pass for inherited deps (via the From keyword)
-    for d in deps_to_process:
-      if isinstance(deps[d], self.FromImpl):
-        # Getting the URL from the sub_deps file can involve having to resolve
-        # a File() or having to resolve a relative URL.  To resolve relative
-        # URLs, we need to pass in the orignal sub deps URL.
-        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)
-        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)):
-      # TODO(phajdan.jr): We should know exactly when the paths are absolute.
-      # It depends on the command being executed (like runhooks vs sync).
-      if not os.path.isabs(file_list[i]):
-        continue
-
-      prefix = os.path.commonprefix([self.root_dir().lower(),
-                                     file_list[i].lower()])
-      file_list[i] = file_list[i][len(prefix):]
-
-      # Strip any leading path separators.
-      while file_list[i].startswith('\\') or file_list[i].startswith('/'):
-        file_list[i] = file_list[i][1:]
-
-    is_using_git = gclient_utils.IsUsingGit(self.root_dir(), entries.keys())
-    self._RunHooks(command, file_list, is_using_git)
+    # Once all the dependencies have been processed, it's now safe to run the
+    # hooks.
+    if not self._options.nohooks:
+      self.RunHooksRecursively(self._options)
 
     if command == 'update':
       # Notify the user if there is an orphaned entry in their working copy.
       # Only delete the directory if there are no changes in it, and
       # delete_unversioned_trees is set to true.
-      prev_entries = self._ReadEntries()
-      for entry in prev_entries:
+      entries = [i.name for i in self.tree(False)]
+      for entry, prev_url in self._ReadEntries().iteritems():
         # Fix path separator on Windows.
         entry_fixed = entry.replace('/', os.path.sep)
         e_dir = os.path.join(self.root_dir(), entry_fixed)
         # Use entry and not entry_fixed there.
         if entry not in entries and os.path.exists(e_dir):
-          modified_files = False
-          if isinstance(prev_entries, list):
-            # old .gclient_entries format was list, now dict
-            modified_files = gclient_scm.scm.SVN.CaptureStatus(e_dir)
-          else:
-            file_list = []
-            scm = gclient_scm.CreateSCM(prev_entries[entry], self.root_dir(),
-                                        entry_fixed)
-            scm.status(self._options, [], file_list)
-            modified_files = file_list != []
+          file_list = []
+          scm = gclient_scm.CreateSCM(prev_url, self.root_dir(), entry_fixed)
+          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()))
             gclient_utils.RemoveDirectory(e_dir)
       # record the current list of entries for next time
-      self._SaveEntries(entries)
+      self._SaveEntries()
     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')
-
-    # 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
-    solution_names = {}
-    entries = {}
-    # Run on the base solutions first.
-    for solution in self.dependencies:
-      # Dictionary of { path : SCM url } to describe the gclient checkout
-      name = solution.name
-      if name in solution_names:
-        raise gclient_utils.Error("solution %s specified more than once" % name)
-      (url, rev) = GetURLAndRev(name, solution.url)
-      entries[name] = "%s@%s" % (url, rev)
-      solution_names[name] = "%s@%s" % (url, rev)
-
-    # Process the dependencies next (sort alphanumerically to ensure that
-    # containing directories get populated first and for readability)
-    deps = self._ParseAllDeps(entries)
-    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 isinstance(deps[d], self.FromImpl):
-        deps_parent_url = entries[deps[d].module_name]
-        if deps_parent_url.find("@") < 0:
-          raise gclient_utils.Error("From %s missing revisioned url" %
-                                        deps[d].module_name)
-        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
+    self.RunCommandRecursively(self._options, {}, None, [], None)
+    def GetActualRevision(i):
+      url, _ = gclient_utils.SplitUrlRevision(i.parsed_url)
+      scm = gclient_scm.CreateSCM(url, self.root_dir(), i.name)
+      if not os.path.isdir(scm.checkout_path):
+        entries[i.name] = None
+      else:
+        entries[i.name] = '%s@%s' % (url, scm.revinfo(self._options, [], None))
     if self._options.snapshot:
-      url = entries.pop(name)
-      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' : '',
-                     'solution_deps': custom_deps,
-                     }
+      new_gclient = ''
+      # First level at .gclient
+      for d in self.dependencies:
+        entries = {}
+        # Lower level at DEPS
+        def GrabDeps(sol):
+          for i in sol.dependencies:
+            GetActualRevision(i)
+            GrabDeps(i)
+        GrabDeps(d)
+        custom_deps = []
+        for k in sorted(entries.keys()):
+          if entries[k]:
+            # Quotes aren't escaped...
+            custom_deps.append('      \"%s\": \'%s\',\n' % (k, entries[k]))
+          else:
+            custom_deps.append('      \"%s\": None,\n' % k)
+        new_gclient += self.DEFAULT_SNAPSHOT_SOLUTION_TEXT % {
+            'solution_name': d.name,
+            'solution_url': d.url,
+            'safesync_url' : d.safesync_url or '',
+            'solution_deps': ''.join(custom_deps),
+        }
+      # Print the snapshot configuration file
+      print(self.DEFAULT_SNAPSHOT_FILE_TEXT % {'solution_list': new_gclient})
     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)
+      entries = {}
+      for i in self.tree(False):
+        if self._options.actual:
+          GetActualRevision(i)
+        else:
+          entries[i.name] = i.parsed_url
+      for x in sorted(entries.keys()):
+        print '%s: %s' % (x, entries[x])
 
   def ParseDepsFile(self, direct_reference):
     """No DEPS to parse for a .gclient file."""
     self.direct_reference = direct_reference
     self.deps_parsed = True
 
   def root_dir(self):
     """Root directory of gclient checkout."""
     return self._root_dir
 
@@ skipping 269 matching lines @@
   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.
   """
   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('-a', '--actual', action='store_true',
+                    help='gets the actual checked out revisions instead of the '
+                         'ones specified in the DEPS and .gclient files')
   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\'')
   client.PrintRevInfo()
   return 0
@@ skipping 75 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: