192 lines
7.0 KiB
Python
192 lines
7.0 KiB
Python
#
|
|
# Copyright (c) 2012, 2013, 2014 Hewlett-Packard Development Company, L.P.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License");
|
|
# you may not use this file except in compliance with the License.
|
|
# You may obtain a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS,
|
|
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
|
# implied.
|
|
# See the License for the specific language governing permissions and
|
|
# limitations under the License.
|
|
#
|
|
|
|
import codecs
|
|
import os
|
|
import subprocess
|
|
|
|
from git_upstream.lib.utils import GitMixin
|
|
from git_upstream.log import LogDedentMixin
|
|
|
|
REBASE_EDITOR_SCRIPT = "rebase-editor"
|
|
|
|
# ensure name of file will match any naming filters used by editors to
|
|
# enable syntax highlighting
|
|
REBASE_EDITOR_TODO = "git-upstream/git-rebase-todo"
|
|
|
|
TODO_EPILOGUE = """
|
|
|
|
# Rebase %(shortrevisions)s onto %(shortonto)s
|
|
#
|
|
# All commands from normal rebase instructions files are supported
|
|
#
|
|
# If you remove a line, that commit will be dropped.
|
|
# Removing all commits will abort the rebase.
|
|
#
|
|
"""
|
|
|
|
|
|
class RebaseEditor(GitMixin, LogDedentMixin):
|
|
|
|
def __init__(self, interactive=False, *args, **kwargs):
|
|
|
|
self._interactive = interactive
|
|
|
|
super(RebaseEditor, self).__init__()
|
|
|
|
self._editor = REBASE_EDITOR_SCRIPT
|
|
# interactive switch here determines if the script that is given
|
|
# to git-rebase to run as it's editor, will in turn exec an editor
|
|
# for the user to look through the instructions before rebase
|
|
# applies them
|
|
if interactive == 'debug':
|
|
self.log.debug("Enabling interactive mode for rebase")
|
|
self._editor = "%s --interactive" % self.editor
|
|
|
|
@property
|
|
def editor(self):
|
|
return self._editor
|
|
|
|
def _write_todo(self, commits, *args, **kwargs):
|
|
todo_file = os.path.join(self.repo.git_dir, REBASE_EDITOR_TODO)
|
|
if os.path.exists(todo_file):
|
|
os.remove(todo_file)
|
|
|
|
if not os.path.exists(os.path.dirname(todo_file)):
|
|
os.mkdir(os.path.dirname(todo_file))
|
|
|
|
# see if onto is set in the args or kwargs
|
|
onto = kwargs.get('onto', None)
|
|
for idx, arg in enumerate(args):
|
|
if arg.startswith("--onto"):
|
|
# either onto is after the option in this arg, or it's the
|
|
# next arg, or not providing it is an exception
|
|
onto = arg[7:] or args[idx + 1]
|
|
break
|
|
|
|
root = None
|
|
with codecs.open(todo_file, "w", "utf-8") as todo:
|
|
for commit in commits:
|
|
if not root:
|
|
root = commit.parents[0]
|
|
subject = commit.message.splitlines()[0]
|
|
todo.write("pick %s %s\n" % (self._shorten(commit), subject))
|
|
|
|
# if root isn't set at this point, then there were no commits
|
|
if not root:
|
|
todo.write("noop\n")
|
|
|
|
todo.write(TODO_EPILOGUE %
|
|
{'shortrevisions': "%s..%s" % (self._shorten(root),
|
|
self._shorten(commit)),
|
|
'shortonto': self._shorten(onto or root)})
|
|
|
|
return todo_file
|
|
|
|
def _shorten(self, commit):
|
|
|
|
if not commit:
|
|
return "<none>"
|
|
|
|
return self.git.rev_parse(commit, short=True)
|
|
|
|
def _set_editor(self, editor):
|
|
|
|
if self.git_sequence_editor:
|
|
self._saveeditor = self.git_sequence_editor
|
|
if self._interactive == 'debug':
|
|
os.environ['GIT_UPSTREAM_GIT_SEQUENCE_EDITOR'] = \
|
|
self._saveeditor
|
|
os.environ['GIT_SEQUENCE_EDITOR'] = editor
|
|
else:
|
|
self._saveeditor = self.git_editor
|
|
if self._interactive == 'debug':
|
|
os.environ['GIT_UPSTREAM_GIT_EDITOR'] = self._saveeditor
|
|
os.environ['GIT_EDITOR'] = editor
|
|
|
|
def _unset_editor(self):
|
|
|
|
for var in ['GIT_SEQUENCE_EDITOR', 'GIT_EDITOR']:
|
|
# GIT_UPSTREAM_* variations should only be set if script was in a
|
|
# debug mode.
|
|
if os.environ.get('GIT_UPSTREAM_' + var, None):
|
|
del os.environ['GIT_UPSTREAM_' + var]
|
|
# Restore previous editor only if the environment var is set. This
|
|
# isn't perfect since we should probably unset the env var if it
|
|
# wasn't previously set, but this shouldn't cause any problems.
|
|
if os.environ.get(var, None):
|
|
os.environ[var] = self._saveeditor
|
|
break
|
|
|
|
def run(self, commits, *args, **kwargs):
|
|
"""
|
|
Reads the list of commits given, and constructions the instructions
|
|
file to be used by rebase.
|
|
Will spawn an editor if the constructor was told to be interactive.
|
|
Additional arguments *args and **kwargs are to be passed to 'git
|
|
rebase'.
|
|
"""
|
|
|
|
todo_file = self._write_todo(commits, *args, **kwargs)
|
|
if self._interactive:
|
|
# spawn the editor
|
|
user_editor = self.git_sequence_editor or self.git_editor
|
|
status = subprocess.call("%s %s" % (user_editor, todo_file),
|
|
shell=True)
|
|
if status:
|
|
return status, None, "Editor returned non-zero exit code"
|
|
|
|
editor = "%s %s" % (self.editor, todo_file)
|
|
self._set_editor(editor)
|
|
|
|
try:
|
|
if self._interactive == 'debug':
|
|
# In general it's not recommended to run rebase in direct
|
|
# interactive mode because it's not possible to capture the
|
|
# stdout/stderr, but sometimes it's useful to allow it for
|
|
# debugging to check the final result.
|
|
#
|
|
# It is not safe to redirect I/O channels as most editors will
|
|
# be expecting that I/O is from/to proper terminal. YMMV
|
|
cmd = ['git', 'rebase', '--interactive']
|
|
cmd.extend(self.git.transform_kwargs(**kwargs))
|
|
cmd.extend(args)
|
|
return subprocess.call(cmd), None, None
|
|
else:
|
|
return self.git.rebase(interactive=True, with_exceptions=False,
|
|
with_extended_output=True, *args,
|
|
**kwargs)
|
|
finally:
|
|
os.remove(todo_file)
|
|
# make sure to remove the environment tweaks added so as not to
|
|
# impact any subsequent use of git commands using editors
|
|
self._unset_editor()
|
|
|
|
@property
|
|
def git_sequence_editor(self):
|
|
|
|
return os.environ.get('GIT_SEQUENCE_EDITOR',
|
|
self.git.config("sequence.editor",
|
|
with_exceptions=False))
|
|
|
|
@property
|
|
def git_editor(self):
|
|
|
|
return os.environ.get("GIT_EDITOR",
|
|
self.git.var("GIT_EDITOR",
|
|
with_exceptions=False))
|