Implement a first pass of `gclient flatten`.

gclient.py

 #!/usr/bin/env python
 # Copyright (c) 2012 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 dependency manager for 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"
@@ skipping 743 matching lines @@
   # pylint: disable=W0221
   def run(self, revision_overrides, command, args, work_queue, options):
     """Runs |command| then parse the DEPS file."""
     logging.info('Dependency(%s).run()' % self.name)
     assert self._file_list == []
     if not self.should_process:
       return
     # 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', 'recurse', None)
+    run_scm = command not in ('flatten', 'runhooks', 'recurse', None)
     parsed_url = self.LateOverride(self.url)
     file_list = [] if not options.nohooks else None
     revision_override = revision_overrides.pop(self.name, None)
     if run_scm and parsed_url:
       # Create a shallow copy to mutate revision.
       options = copy.copy(options)
       options.revision = revision_override
       self._used_revision = options.revision
       self._used_scm = gclient_scm.CreateSCM(
           parsed_url, self.root.root_dir, self.name, self.outbuf,
@@ skipping 873 matching lines @@
   for scm in options.scm:
     scm_set.update(scm.split(','))
   options.scm = scm_set
 
   options.nohooks = True
   client = GClient.LoadCurrentConfig(options)
   return client.RunOnDeps('recurse', args, ignore_requirements=True,
                           progress=not options.no_progress)
 
 
+@subcommand.usage('[command] [--verify] [args ...]')
+def CMDflatten(parser, args):
+  """Flattens the solutions into a single DEPS file."""
+  # Stop parsing at the first non-arg so that these go through to the command
+  parser.add_option('--verify', action='store_true',
+                    help='Verifies that each dependencies is pinned at a '
+                         'specific revision.')

[agable, 2016/11/02 17:53:26]

And that the .gclient_entries file matches what's actually on the filesystem,
maybe?

[Dirk Pranke, 2016/11/02 19:01:22]

I'm not sure how useful that is, but I'm not actually sure what all
.gclient_entries is even used for?

[Michael Moss, 2016/11/02 20:50:30]

Assuming --verify ends up using gitiles requests, it wouldn't necessarily work
as the same command to verify a checkout, but we could have two types of
verification. Maybe --validate (syntax and hashes) and --fsck (with it's implied
meaning of checking stuff on disk), or something like that.

+  options, args = parser.parse_args(args)
+  root_and_entries = gclient_utils.GetGClientRootAndEntries()
+  if not root_and_entries:
+    print(
+        'You need to run gclient sync at least once to use \'flatten\'.\n'
+        'This is because .gclient_entries needs to exist and be up to date.',
+        file=sys.stderr)
+    return 1
+
+  options.nohooks = True
+  client = GClient.LoadCurrentConfig(options)
+  res = client.RunOnDeps('flatten', args, ignore_requirements=True,
+                         progress=False)
+  if res:
+    return res
+
+  deps = {}
+  hooks = []
+  unpinned_deps = {}
+
+  for solution in client.dependencies:
+    _FlattenSolution(solution, deps, hooks, unpinned_deps)
+
+  if options.verify and unpinned_deps:
+    for name in unpinned_deps:
+      print("'%s' is not pinned to a Git revision" % name)
+    return 1
+
+  flattened_deps = ('%s\n%s\n' %
+                    (_DepsToVarString(deps), _HooksToVarString(hooks)))
+  print(flattened_deps)
+  return 0
+
+
+def _FlattenSolution(solution, deps, hooks, unpinned_deps):
+  _AddDep(solution, deps, unpinned_deps)
+  for dep in solution.dependencies:
+    _FlattenDep(dep, deps, hooks, unpinned_deps)
+  hooks.extend(solution.deps_hooks)
+
+
+def _FlattenDep(dep, deps, hooks, unpinned_deps):
+  _AddDep(dep, deps, unpinned_deps)
+  for recurse_dep_name in sorted(dep.recursedeps or []):
+    for sub_dep in dep.dependencies:
+      if recurse_dep_name == dep.name:
+        _FlattenDep(sub_dep, deps, hooks, unpinned_deps)
+      break
+  hooks.extend(dep.deps_hooks)
+
+
+def _AddDep(dep, deps, unpinned_deps):
+  assert dep.name not in deps
+  deps[dep.name] = dep.url
+  _, revision = gclient_utils.SplitUrlRevision(dep.url)
+  if not revision or not gclient_utils.IsGitSha(revision):
+    unpinned_deps[dep.name] = dep.url
+
+
+def _DepsToVarString(deps):
+  s = "deps = {\n"
+  for name in sorted(deps):
+    s += "  '%s': '%s',\n" % (name, deps[name])
+  s += "}\n"
+  return s
+
+
+def _HooksToVarString(hooks):
+  s = "hooks = [\n"
+  for hook in hooks:
+    s += "  {\n"

[agable, 2016/11/02 17:53:26]

Make this a triple-quoted multi-line template string rather than doing lots of
string concatenation.

[Dirk Pranke, 2016/11/02 19:01:22]

I originally didn't do this because I thought handling the conditionals would
make this harder to read. But I'll code up something and we can compare.

+    if 'name' in hook:
+      s += "    'name': '%s',\n" % hook['name']
+    if 'pattern' in hook:
+      s += "    'pattern': '%s',\n" % hook['pattern']
+    s += "    'action': [\n"
+    s += "      "
+    s += ",\n      ".join("'%s'" % arg for arg in hook['action'])
+    s += ",\n"
+    s += "    ],\n"
+    s += "  },\n"
+  s += "}"
+  return s
+
+
 @subcommand.usage('[args ...]')
 def CMDfetch(parser, args):
   """Fetches upstream commits for all modules.
 
   Completely git-specific. Simply runs 'git fetch [args ...]' for each module.
   """
   (options, args) = parser.parse_args(args)
   return CMDrecurse(OptionParser(), [
       '--jobs=%d' % options.jobs, '--scm=git', 'git', 'fetch'] + args)
 
@@ skipping 512 matching lines @@
 
 
 if '__main__' == __name__:
   try:
     sys.exit(main(sys.argv[1:]))
   except KeyboardInterrupt:
     sys.stderr.write('interrupted\n')
     sys.exit(1)
 
 # vim: ts=2:sw=2:tw=80:et: