Move all revision parsing code to _EnforceRevisions.

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 488 matching lines @@
     # 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 _EnforceRevisions(self, solutions):
     """Checks for revision overrides."""
     revision_overrides = {}
-    solutions = [s['name'] for s in solutions]
-    if self._options.revisions:
-      revision = self._options.revisions[0]
-      # Ignore solution@
-      rev = revision
-      if '@' in revision:
-        rev = revision.split('@', 1)[1]
-      revision_overrides[solutions[0]] = rev
-
-    if len(self._options.revisions) > 1:
-      # Enforce solution@rev format for following params.
-      for revision in self._options.revisions[1:]:
-        if not '@' in revision:
-          raise gclient_utils.Error(
-              'Specify the full dependency when specifying a revision number '
-              'for non-primary solution.')
-        sol, rev = revision.split("@", 1)
-        # Disallow conflicting revs
-        if revision_overrides.get(sol, rev) != rev:
-          raise gclient_utils.Error(
-              'Conflicting revision numbers specified for %s: %s and %s.' %
-                  (sol, revision_overrides[sol], rev))
-        if not sol in solutions:
-          raise gclient_utils.Error('%s is not a valid solution.' % sol)
+    if self._options.head:
+      return revision_overrides
+    for s in solutions:
+      if not s.get('safesync_url', None):
+        continue
+      handle = urllib.urlopen(s['safesync_url'])
+      rev = handle.read().strip()
+      handle.close()
+      if len(rev):
+        self._options.revisions.append('%s@%s' % (s['name'], rev))
+    if not self._options.revisions:
+      return revision_overrides
+    # --revision will take over safesync_url.
+    solutions_names = [s['name'] for s in solutions]
+    index = 0
+    for revision in self._options.revisions:
+      if not '@' in revision:
+        # Support for --revision 123
+        revision = '%s@%s' % (solutions_names[index], revision)
+      sol, rev = revision.split("@", 1)
+      if not sol in solutions_names:
+        #raise gclient_utils.Error('%s is not a valid solution.' % sol)
+        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.
@@ skipping 391 matching lines @@
       update src directory to r31000
 """)
 def CMDsync(parser, args):
   """Checkout/update all modules."""
   parser.add_option("--force", action="store_true",
                     help="force update even for unchanged modules")
   parser.add_option("--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 primary solution. "
-                         "To modify a secondary solution, use it at least once "
-                         "for the primary solution and then use the format "
-                         "solution@rev/hash, e.g. -r src@123")
+                    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("--head", action="store_true",
                     help="skips any safesync_urls specified in "
                          "configured solutions and sync to head instead")
   parser.add_option("--delete_unversioned_trees", action="store_true",
                     help="delete any unexpected unversioned trees "
                          "that are in the checkout")
   parser.add_option("--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("--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'")
 
-  if not options.head:
-    solutions = client.GetVar('solutions')
-    if solutions:
-      first = True
-      for s in solutions:
-        if s.get('safesync_url', None):
-          # rip through revisions and make sure we're not over-riding
-          # something that was explicitly passed
-          has_key = False
-          r_first = True
-          for r in options.revisions:
-            if (first and r_first) or r.split('@', 1)[0] == s['name']:
-              has_key = True
-              break
-            r_first = False
-
-          if not has_key:
-            handle = urllib.urlopen(s['safesync_url'])
-            rev = handle.read().strip()
-            handle.close()
-            if len(rev):
-              options.revisions.append(s['name']+'@'+rev)
-        first = False
+  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())
   return client.RunOnDeps('update', args)
 
 
 def CMDupdate(parser, args):
   """Alias for the sync command. Deprecated."""
@@ skipping 115 matching lines @@
   def Parse(args):
     (options, args) = old_parser(args)
     if options.verbose == 2:
       logging.basicConfig(level=logging.INFO)
     elif options.verbose > 2:
       logging.basicConfig(level=logging.DEBUG)
     options.entries_filename = options.config_filename + "_entries"
     if not hasattr(options, 'revisions'):
       # GClient.RunOnDeps expects it even if not applicable.
       options.revisions = []
+    if not hasattr(options, 'head'):
+      options.head = None
     return (options, args)
   parser.parse_args = Parse
   # We don't want wordwrapping in epilog (usually examples)
   parser.format_epilog = lambda _: parser.epilog or ''
   if argv:
     command = Command(argv[0])
     if command:
       # "fix" the usage and the description now that we know the subcommand.
       GenUsage(parser, argv[0])
       return command(parser, argv[1:])
   # Not a known command. Default to help.
   GenUsage(parser, 'help')
   return CMDhelp(parser, argv)
 
 
 if "__main__" == __name__:
   try:
     sys.exit(Main(sys.argv[1:]))
   except gclient_utils.Error, e:
     print >> sys.stderr, "Error: %s" % str(e)
     sys.exit(1)
 
 # vim: ts=2:sw=2:tw=80:et: