Merge instead of rebasing upstream changes in `gclient sync` when --merge is given.

gclient_scm.py

 # 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.
 
 """Gclient-specific SCM-specific operations."""
 
 import collections
 import logging
 import os
 import posixpath
@@ skipping 451 matching lines @@
       self._CheckClean(rev_str)
       self._CheckDetachedHead(rev_str, options)
       self._Capture(['checkout', '--quiet', '%s' % revision])
       if not printed_path:
         print('\n_____ %s%s' % (self.relpath, rev_str))
     elif current_type == 'hash':
       # case 1
       if scm.GIT.IsGitSvn(self.checkout_path) and upstream_branch is not None:
         # Our git-svn branch (upstream_branch) is our upstream
         self._AttemptRebase(upstream_branch, files, options,
-                            newbase=revision, printed_path=printed_path)
+                            newbase=revision, printed_path=printed_path,
+                            merge=options.merge)
         printed_path = True
       else:
         # Can't find a merge-base since we don't know our upstream. That makes
         # this command VERY likely to produce a rebase failure. For now we
         # assume origin is our upstream since that's what the old behavior was.
         upstream_branch = self.remote
         if options.revision or deps_revision:
           upstream_branch = revision
         self._AttemptRebase(upstream_branch, files, options,
-                            printed_path=printed_path)
+                            printed_path=printed_path, merge=options.merge)
         printed_path = True
     elif rev_type == 'hash':
       # case 2
       self._AttemptRebase(upstream_branch, files, options,
-                          newbase=revision, printed_path=printed_path)
+                          newbase=revision, printed_path=printed_path,
+                          merge=options.merge)
       printed_path = True
     elif revision.replace('heads', 'remotes/' + self.remote) != upstream_branch:
       # case 4
       new_base = revision.replace('heads', 'remotes/' + self.remote)
       if not printed_path:
         print('\n_____ %s%s' % (self.relpath, rev_str))
       switch_error = ("Switching upstream branch from %s to %s\n"
                      % (upstream_branch, new_base) +
                      "Please merge or rebase manually:\n" +
                      "cd %s; git rebase %s\n" % (self.checkout_path, new_base) +
@@ skipping 12 matching lines @@
         merge_args.append(upstream_branch)
         merge_output = scm.GIT.Capture(merge_args, cwd=self.checkout_path)
       except subprocess2.CalledProcessError as e:
         if re.match('fatal: Not possible to fast-forward, aborting.', e.stderr):
           if not printed_path:
             print('\n_____ %s%s' % (self.relpath, rev_str))
             printed_path = True
           while True:
             try:
               action = ask_for_data(
-                  'Cannot fast-forward merge, attempt to rebase? '
-                  '(y)es / (q)uit / (s)kip : ', options)
+                  'Cannot %s, attempt to rebase? '
+                  '(y)es / (q)uit / (s)kip : ' %
+                      'merge' if options.merge else 'fast-forward merge',

[iannucci, 2013/12/16 21:01:15]

Wouldn't we want to still fast-forward, even if merge was selected? I think you
want to parameterize the rebase portion here, not the f-f-m.

[Bernhard Bauer, 2013/12/16 21:39:03]

With this version (and --merge), we will still try to fast-forward first, but
automatically try to merge if we cannot do that (by virtue of calling `git
merge` without --ff-only), and only offer to rebase if that fails. With your
suggestion, we would never rebase, and ask for confirmation before merging. I'm
not sure if that is really necessary, as merging is easier to undo than
rebasing.

+                  options)
             except ValueError:
               raise gclient_utils.Error('Invalid Character')
             if re.match(r'yes|y', action, re.I):
               self._AttemptRebase(upstream_branch, files, options,
-                                  printed_path=printed_path)
+                                  printed_path=printed_path, merge=False)
               printed_path = True
               break
             elif re.match(r'quit|q', action, re.I):
               raise gclient_utils.Error("Can't fast-forward, please merge or "
                                         "rebase manually.\n"
                                         "cd %s && git " % self.checkout_path
                                         + "rebase %s" % upstream_branch)
             elif re.match(r'skip|s', action, re.I):
               print('Skipping %s' % self.relpath)
               return
@@ skipping 336 matching lines @@
     else:
       # Squelch git's very verbose detached HEAD warning and use our own
       self._Run(['checkout', '--quiet', revision], options)
       print(
         ('Checked out %s to a detached HEAD. Before making any commits\n'
          'in this repo, you should use \'git checkout <branch>\' to switch to\n'
          'an existing branch or use \'git checkout %s -b <branch>\' to\n'
          'create a new branch for your work.') % (revision, self.remote))
 
   def _AttemptRebase(self, upstream, files, options, newbase=None,
-                     branch=None, printed_path=False):
+                     branch=None, printed_path=False, merge=False):
     """Attempt to rebase onto either upstream or, if specified, newbase."""
     if files is not None:
       files.extend(self._Capture(['diff', upstream, '--name-only']).split())
     revision = upstream
     if newbase:
       revision = newbase
+    action = 'merge' if merge else 'rebase'
     if not printed_path:
-      print('\n_____ %s : Attempting rebase onto %s...' % (
-          self.relpath, revision))
+      print('\n_____ %s : Attempting %s onto %s...' % (
+          action, self.relpath, revision))
       printed_path = True
     else:
-      print('Attempting rebase onto %s...' % revision)
+      print('Attempting %s onto %s...' % (action, revision))
+
+    if merge:
+      merge_output = self._Capture(['merge', revision])
+      if options.verbose:
+        print(merge_output)
+      return
 
     # Build the rebase command here using the args
     # git rebase [options] [--onto <newbase>] <upstream> [<branch>]
     rebase_cmd = ['rebase']
     if options.verbose:
       rebase_cmd.append('--verbose')
     if newbase:
       rebase_cmd.extend(['--onto', newbase])
     rebase_cmd.append(upstream)
     if branch:
@@ skipping 546 matching lines @@
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'theirs-conflict'))
     elif options.manually_grab_svn_rev:
       new_command.append('--force')
       if command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
         new_command.extend(('--accept', 'postpone'))
     elif command[0] != 'checkout' and scm.SVN.AssertVersion('1.6')[0]:
       new_command.extend(('--accept', 'postpone'))
     return new_command