cola/cmds.py

   1 """Editor commands"""
   2 from __future__ import division, absolute_import, unicode_literals
   3 import os
   4 import re
   5 import sys
   6 from fnmatch import fnmatch
   7 from io import StringIO
   8
   9 try:
  10     from send2trash import send2trash
  11 except ImportError:
  12     send2trash = None
  13
  14 from . import compat
  15 from . import core
  16 from . import gitcmds
  17 from . import icons
  18 from . import resources
  19 from . import textwrap
  20 from . import utils
  21 from . import version
  22 from .cmd import ContextCommand
  23 from .diffparse import DiffParser
  24 from .git import STDOUT
  25 from .git import EMPTY_TREE_OID
  26 from .git import MISSING_BLOB_OID
  27 from .i18n import N_
  28 from .interaction import Interaction
  29 from .models import main
  30 from .models import prefs
  31
  32
  33 class UsageError(Exception):
  34     """Exception class for usage errors."""
  35
  36     def __init__(self, title, message):
  37         Exception.__init__(self, message)
  38         self.title = title
  39         self.msg = message
  40
  41
  42 class EditModel(ContextCommand):
  43     """Commands that mutate the main model diff data"""
  44
  45     UNDOABLE = True
  46
  47     def __init__(self, context):
  48         """Common edit operations on the main model"""
  49         super(EditModel, self).__init__(context)
  50
  51         self.old_diff_text = self.model.diff_text
  52         self.old_filename = self.model.filename
  53         self.old_mode = self.model.mode
  54         self.old_diff_type = self.model.diff_type
  55         self.old_file_type = self.model.file_type
  56
  57         self.new_diff_text = self.old_diff_text
  58         self.new_filename = self.old_filename
  59         self.new_mode = self.old_mode
  60         self.new_diff_type = self.old_diff_type
  61         self.new_file_type = self.old_file_type
  62
  63     def do(self):
  64         """Perform the operation."""
  65         self.model.set_filename(self.new_filename)
  66         self.model.set_mode(self.new_mode)
  67         self.model.set_diff_text(self.new_diff_text)
  68         self.model.set_diff_type(self.new_diff_type)
  69         self.model.set_file_type(self.new_file_type)
  70
  71     def undo(self):
  72         """Undo the operation."""
  73         self.model.set_filename(self.old_filename)
  74         self.model.set_mode(self.old_mode)
  75         self.model.set_diff_text(self.old_diff_text)
  76         self.model.set_diff_type(self.old_diff_type)
  77         self.model.set_file_type(self.old_file_type)
  78
  79
  80 class ConfirmAction(ContextCommand):
  81     """Confirm an action before running it"""
  82
  83     # pylint: disable=no-self-use
  84     def ok_to_run(self):
  85         """Return True when the command is ok to run"""
  86         return True
  87
  88     # pylint: disable=no-self-use
  89     def confirm(self):
  90         """Prompt for confirmation"""
  91         return True
  92
  93     # pylint: disable=no-self-use
  94     def action(self):
  95         """Run the command and return (status, out, err)"""
  96         return (-1, '', '')
  97
  98     # pylint: disable=no-self-use
  99     def success(self):
 100         """Callback run on success"""
 101         return
 102
 103     # pylint: disable=no-self-use
 104     def command(self):
 105         """Command name, for error messages"""
 106         return 'git'
 107
 108     # pylint: disable=no-self-use
 109     def error_message(self):
 110         """Command error message"""
 111         return ''
 112
 113     def do(self):
 114         """Prompt for confirmation before running a command"""
 115         status = -1
 116         out = err = ''
 117         ok = self.ok_to_run() and self.confirm()
 118         if ok:
 119             status, out, err = self.action()
 120             if status == 0:
 121                 self.success()
 122             title = self.error_message()
 123             cmd = self.command()
 124             Interaction.command(title, cmd, status, out, err)
 125
 126         return ok, status, out, err
 127
 128
 129 class AbortMerge(ConfirmAction):
 130     """Reset an in-progress merge back to HEAD"""
 131
 132     def confirm(self):
 133         title = N_('Abort Merge...')
 134         question = N_('Aborting the current merge?')
 135         info = N_(
 136             'Aborting the current merge will cause '
 137             '*ALL* uncommitted changes to be lost.\n'
 138             'Recovering uncommitted changes is not possible.'
 139         )
 140         ok_txt = N_('Abort Merge')
 141         return Interaction.confirm(
 142             title, question, info, ok_txt, default=False, icon=icons.undo()
 143         )
 144
 145     def action(self):
 146         status, out, err = gitcmds.abort_merge(self.context)
 147         self.model.update_file_status()
 148         return status, out, err
 149
 150     def success(self):
 151         self.model.set_commitmsg('')
 152
 153     def error_message(self):
 154         return N_('Error')
 155
 156     def command(self):
 157         return 'git merge'
 158
 159
 160 class AmendMode(EditModel):
 161     """Try to amend a commit."""
 162
 163     UNDOABLE = True
 164     LAST_MESSAGE = None
 165
 166     @staticmethod
 167     def name():
 168         return N_('Amend')
 169
 170     def __init__(self, context, amend=True):
 171         super(AmendMode, self).__init__(context)
 172         self.skip = False
 173         self.amending = amend
 174         self.old_commitmsg = self.model.commitmsg
 175         self.old_mode = self.model.mode
 176
 177         if self.amending:
 178             self.new_mode = self.model.mode_amend
 179             self.new_commitmsg = gitcmds.prev_commitmsg(context)
 180             AmendMode.LAST_MESSAGE = self.model.commitmsg
 181             return
 182         # else, amend unchecked, regular commit
 183         self.new_mode = self.model.mode_none
 184         self.new_diff_text = ''
 185         self.new_commitmsg = self.model.commitmsg
 186         # If we're going back into new-commit-mode then search the
 187         # undo stack for a previous amend-commit-mode and grab the
 188         # commit message at that point in time.
 189         if AmendMode.LAST_MESSAGE is not None:
 190             self.new_commitmsg = AmendMode.LAST_MESSAGE
 191             AmendMode.LAST_MESSAGE = None
 192
 193     def do(self):
 194         """Leave/enter amend mode."""
 195         # Attempt to enter amend mode.  Do not allow this when merging.
 196         if self.amending:
 197             if self.model.is_merging:
 198                 self.skip = True
 199                 self.model.set_mode(self.old_mode)
 200                 Interaction.information(
 201                     N_('Cannot Amend'),
 202                     N_(
 203                         'You are in the middle of a merge.\n'
 204                         'Cannot amend while merging.'
 205                     ),
 206                 )
 207                 return
 208         self.skip = False
 209         super(AmendMode, self).do()
 210         self.model.set_commitmsg(self.new_commitmsg)
 211         self.model.update_file_status()
 212
 213     def undo(self):
 214         if self.skip:
 215             return
 216         self.model.set_commitmsg(self.old_commitmsg)
 217         super(AmendMode, self).undo()
 218         self.model.update_file_status()
 219
 220
 221 class AnnexAdd(ContextCommand):
 222     """Add to Git Annex"""
 223
 224     def __init__(self, context):
 225         super(AnnexAdd, self).__init__(context)
 226         self.filename = self.selection.filename()
 227
 228     def do(self):
 229         status, out, err = self.git.annex('add', self.filename)
 230         Interaction.command(N_('Error'), 'git annex add', status, out, err)
 231         self.model.update_status()
 232
 233
 234 class AnnexInit(ContextCommand):
 235     """Initialize Git Annex"""
 236
 237     def do(self):
 238         status, out, err = self.git.annex('init')
 239         Interaction.command(N_('Error'), 'git annex init', status, out, err)
 240         self.model.cfg.reset()
 241         self.model.emit_updated()
 242
 243
 244 class LFSTrack(ContextCommand):
 245     """Add a file to git lfs"""
 246
 247     def __init__(self, context):
 248         super(LFSTrack, self).__init__(context)
 249         self.filename = self.selection.filename()
 250         self.stage_cmd = Stage(context, [self.filename])
 251
 252     def do(self):
 253         status, out, err = self.git.lfs('track', self.filename)
 254         Interaction.command(N_('Error'), 'git lfs track', status, out, err)
 255         if status == 0:
 256             self.stage_cmd.do()
 257
 258
 259 class LFSInstall(ContextCommand):
 260     """Initialize git lfs"""
 261
 262     def do(self):
 263         status, out, err = self.git.lfs('install')
 264         Interaction.command(N_('Error'), 'git lfs install', status, out, err)
 265         self.model.update_config(reset=True, emit=True)
 266
 267
 268 class ApplyDiffSelection(ContextCommand):
 269     """Apply the selected diff to the worktree or index"""
 270
 271     def __init__(
 272         self,
 273         context,
 274         first_line_idx,
 275         last_line_idx,
 276         has_selection,
 277         reverse,
 278         apply_to_worktree,
 279     ):
 280         super(ApplyDiffSelection, self).__init__(context)
 281         self.first_line_idx = first_line_idx
 282         self.last_line_idx = last_line_idx
 283         self.has_selection = has_selection
 284         self.reverse = reverse
 285         self.apply_to_worktree = apply_to_worktree
 286
 287     def do(self):
 288         context = self.context
 289         cfg = self.context.cfg
 290         diff_text = self.model.diff_text
 291
 292         parser = DiffParser(self.model.filename, diff_text)
 293         if self.has_selection:
 294             patch = parser.generate_patch(
 295                 self.first_line_idx, self.last_line_idx, reverse=self.reverse
 296             )
 297         else:
 298             patch = parser.generate_hunk_patch(
 299                 self.first_line_idx, reverse=self.reverse
 300             )
 301         if patch is None:
 302             return
 303
 304         if isinstance(diff_text, core.UStr):
 305             # original encoding must prevail
 306             encoding = diff_text.encoding
 307         else:
 308             encoding = cfg.file_encoding(self.model.filename)
 309
 310         tmp_file = utils.tmp_filename('patch')
 311         try:
 312             core.write(tmp_file, patch, encoding=encoding)
 313             if self.apply_to_worktree:
 314                 status, out, err = gitcmds.apply_diff_to_worktree(context, tmp_file)
 315             else:
 316                 status, out, err = gitcmds.apply_diff(context, tmp_file)
 317         finally:
 318             core.unlink(tmp_file)
 319
 320         Interaction.log_status(status, out, err)
 321         self.model.update_file_status(update_index=True)
 322
 323
 324 class ApplyPatches(ContextCommand):
 325     """Apply patches using the "git am" command"""
 326
 327     def __init__(self, context, patches):
 328         super(ApplyPatches, self).__init__(context)
 329         self.patches = patches
 330
 331     def do(self):
 332         status, out, err = self.git.am('-3', *self.patches)
 333         Interaction.log_status(status, out, err)
 334
 335         # Display a diffstat
 336         self.model.update_file_status()
 337
 338         patch_basenames = [os.path.basename(p) for p in self.patches]
 339         if len(patch_basenames) > 25:
 340             patch_basenames = patch_basenames[:25]
 341             patch_basenames.append('...')
 342
 343         basenames = '\n'.join(patch_basenames)
 344         Interaction.information(
 345             N_('Patch(es) Applied'),
 346             (N_('%d patch(es) applied.') + '\n\n%s') % (len(self.patches), basenames),
 347         )
 348
 349
 350 class Archive(ContextCommand):
 351     """"Export archives using the "git archive" command"""
 352
 353     def __init__(self, context, ref, fmt, prefix, filename):
 354         super(Archive, self).__init__(context)
 355         self.ref = ref
 356         self.fmt = fmt
 357         self.prefix = prefix
 358         self.filename = filename
 359
 360     def do(self):
 361         fp = core.xopen(self.filename, 'wb')
 362         cmd = ['git', 'archive', '--format=' + self.fmt]
 363         if self.fmt in ('tgz', 'tar.gz'):
 364             cmd.append('-9')
 365         if self.prefix:
 366             cmd.append('--prefix=' + self.prefix)
 367         cmd.append(self.ref)
 368         proc = core.start_command(cmd, stdout=fp)
 369         out, err = proc.communicate()
 370         fp.close()
 371         status = proc.returncode
 372         Interaction.log_status(status, out or '', err or '')
 373
 374
 375 class Checkout(EditModel):
 376     """A command object for git-checkout.
 377
 378     'argv' is handed off directly to git.
 379
 380     """
 381
 382     def __init__(self, context, argv, checkout_branch=False):
 383         super(Checkout, self).__init__(context)
 384         self.argv = argv
 385         self.checkout_branch = checkout_branch
 386         self.new_diff_text = ''
 387         self.new_diff_type = main.Types.TEXT
 388         self.new_file_type = main.Types.TEXT
 389
 390     def do(self):
 391         super(Checkout, self).do()
 392         status, out, err = self.git.checkout(*self.argv)
 393         if self.checkout_branch:
 394             self.model.update_status()
 395         else:
 396             self.model.update_file_status()
 397         Interaction.command(N_('Error'), 'git checkout', status, out, err)
 398
 399
 400 class BlamePaths(ContextCommand):
 401     """Blame view for paths."""
 402
 403     @staticmethod
 404     def name():
 405         return N_('Blame...')
 406
 407     def __init__(self, context, paths=None):
 408         super(BlamePaths, self).__init__(context)
 409         if not paths:
 410             paths = context.selection.union()
 411         viewer = utils.shell_split(prefs.blame_viewer(context))
 412         self.argv = viewer + list(paths)
 413
 414     def do(self):
 415         try:
 416             core.fork(self.argv)
 417         except OSError as e:
 418             _, details = utils.format_exception(e)
 419             title = N_('Error Launching Blame Viewer')
 420             msg = N_('Cannot exec "%s": please configure a blame viewer') % ' '.join(
 421                 self.argv
 422             )
 423             Interaction.critical(title, message=msg, details=details)
 424
 425
 426 class CheckoutBranch(Checkout):
 427     """Checkout a branch."""
 428
 429     def __init__(self, context, branch):
 430         args = [branch]
 431         super(CheckoutBranch, self).__init__(context, args, checkout_branch=True)
 432
 433
 434 class CherryPick(ContextCommand):
 435     """Cherry pick commits into the current branch."""
 436
 437     def __init__(self, context, commits):
 438         super(CherryPick, self).__init__(context)
 439         self.commits = commits
 440
 441     def do(self):
 442         self.model.cherry_pick_list(self.commits)
 443         self.model.update_file_status()
 444
 445
 446 class Revert(ContextCommand):
 447     """Cherry pick commits into the current branch."""
 448
 449     def __init__(self, context, oid):
 450         super(Revert, self).__init__(context)
 451         self.oid = oid
 452
 453     def do(self):
 454         self.git.revert(self.oid, no_edit=True)
 455         self.model.update_file_status()
 456
 457
 458 class ResetMode(EditModel):
 459     """Reset the mode and clear the model's diff text."""
 460
 461     def __init__(self, context):
 462         super(ResetMode, self).__init__(context)
 463         self.new_mode = self.model.mode_none
 464         self.new_diff_text = ''
 465         self.new_diff_type = main.Types.TEXT
 466         self.new_file_type = main.Types.TEXT
 467         self.new_filename = ''
 468
 469     def do(self):
 470         super(ResetMode, self).do()
 471         self.model.update_file_status()
 472
 473
 474 class ResetCommand(ConfirmAction):
 475     """Reset state using the "git reset" command"""
 476
 477     def __init__(self, context, ref):
 478         super(ResetCommand, self).__init__(context)
 479         self.ref = ref
 480
 481     def action(self):
 482         return self.reset()
 483
 484     def command(self):
 485         return 'git reset'
 486
 487     def error_message(self):
 488         return N_('Error')
 489
 490     def success(self):
 491         self.model.update_file_status()
 492
 493     def confirm(self):
 494         raise NotImplementedError('confirm() must be overridden')
 495
 496     def reset(self):
 497         raise NotImplementedError('reset() must be overridden')
 498
 499
 500 class ResetMixed(ResetCommand):
 501     @staticmethod
 502     def tooltip(ref):
 503         tooltip = N_('The branch will be reset using "git reset --mixed %s"')
 504         return tooltip % ref
 505
 506     def confirm(self):
 507         title = N_('Reset Branch and Stage (Mixed)')
 508         question = N_('Point the current branch head to a new commit?')
 509         info = self.tooltip(self.ref)
 510         ok_text = N_('Reset Branch')
 511         return Interaction.confirm(title, question, info, ok_text)
 512
 513     def reset(self):
 514         return self.git.reset(self.ref, '--', mixed=True)
 515
 516
 517 class ResetKeep(ResetCommand):
 518     @staticmethod
 519     def tooltip(ref):
 520         tooltip = N_('The repository will be reset using "git reset --keep %s"')
 521         return tooltip % ref
 522
 523     def confirm(self):
 524         title = N_('Restore Worktree and Reset All (Keep Unstaged Changes)')
 525         question = N_('Restore worktree, reset, and preserve unstaged edits?')
 526         info = self.tooltip(self.ref)
 527         ok_text = N_('Reset and Restore')
 528         return Interaction.confirm(title, question, info, ok_text)
 529
 530     def reset(self):
 531         return self.git.reset(self.ref, '--', keep=True)
 532
 533
 534 class ResetMerge(ResetCommand):
 535     @staticmethod
 536     def tooltip(ref):
 537         tooltip = N_('The repository will be reset using "git reset --merge %s"')
 538         return tooltip % ref
 539
 540     def confirm(self):
 541         title = N_('Restore Worktree and Reset All (Merge)')
 542         question = N_('Reset Worktree and Reset All?')
 543         info = self.tooltip(self.ref)
 544         ok_text = N_('Reset and Restore')
 545         return Interaction.confirm(title, question, info, ok_text)
 546
 547     def reset(self):
 548         return self.git.reset(self.ref, '--', merge=True)
 549
 550
 551 class ResetSoft(ResetCommand):
 552     @staticmethod
 553     def tooltip(ref):
 554         tooltip = N_('The branch will be reset using "git reset --soft %s"')
 555         return tooltip % ref
 556
 557     def confirm(self):
 558         title = N_('Reset Branch (Soft)')
 559         question = N_('Reset branch?')
 560         info = self.tooltip(self.ref)
 561         ok_text = N_('Reset Branch')
 562         return Interaction.confirm(title, question, info, ok_text)
 563
 564     def reset(self):
 565         return self.git.reset(self.ref, '--', soft=True)
 566
 567
 568 class ResetHard(ResetCommand):
 569     @staticmethod
 570     def tooltip(ref):
 571         tooltip = N_('The repository will be reset using "git reset --hard %s"')
 572         return tooltip % ref
 573
 574     def confirm(self):
 575         title = N_('Restore Worktree and Reset All (Hard)')
 576         question = N_('Restore Worktree and Reset All?')
 577         info = self.tooltip(self.ref)
 578         ok_text = N_('Reset and Restore')
 579         return Interaction.confirm(title, question, info, ok_text)
 580
 581     def reset(self):
 582         return self.git.reset(self.ref, '--', hard=True)
 583
 584
 585 class RestoreWorktree(ConfirmAction):
 586     """Reset the worktree using the "git read-tree" command"""
 587
 588     @staticmethod
 589     def tooltip(ref):
 590         tooltip = N_(
 591             'The worktree will be restored using "git read-tree --reset -u %s"'
 592         )
 593         return tooltip % ref
 594
 595     def __init__(self, context, ref):
 596         super(RestoreWorktree, self).__init__(context)
 597         self.ref = ref
 598
 599     def action(self):
 600         return self.git.read_tree(self.ref, reset=True, u=True)
 601
 602     def command(self):
 603         return 'git read-tree --reset -u %s' % self.ref
 604
 605     def error_message(self):
 606         return N_('Error')
 607
 608     def success(self):
 609         self.model.update_file_status()
 610
 611     def confirm(self):
 612         title = N_('Restore Worktree')
 613         question = N_('Restore Worktree to %s?') % self.ref
 614         info = self.tooltip(self.ref)
 615         ok_text = N_('Restore Worktree')
 616         return Interaction.confirm(title, question, info, ok_text)
 617
 618
 619 class UndoLastCommit(ResetCommand):
 620     """Undo the last commit"""
 621
 622     # NOTE: this is the similar to ResetSoft() with an additional check for
 623     # published commits and different messages.
 624     def __init__(self, context):
 625         super(UndoLastCommit, self).__init__(context, 'HEAD^')
 626
 627     def confirm(self):
 628         check_published = prefs.check_published_commits(self.context)
 629         if check_published and self.model.is_commit_published():
 630             return Interaction.confirm(
 631                 N_('Rewrite Published Commit?'),
 632                 N_(
 633                     'This commit has already been published.\n'
 634                     'This operation will rewrite published history.\n'
 635                     'You probably don\'t want to do this.'
 636                 ),
 637                 N_('Undo the published commit?'),
 638                 N_('Undo Last Commit'),
 639                 default=False,
 640                 icon=icons.save(),
 641             )
 642
 643         title = N_('Undo Last Commit')
 644         question = N_('Undo last commit?')
 645         info = N_('The branch will be reset using "git reset --soft %s"')
 646         ok_text = N_('Undo Last Commit')
 647         info_text = info % self.ref
 648         return Interaction.confirm(title, question, info_text, ok_text)
 649
 650     def reset(self):
 651         return self.git.reset('HEAD^', '--', soft=True)
 652
 653
 654 class Commit(ResetMode):
 655     """Attempt to create a new commit."""
 656
 657     def __init__(self, context, amend, msg, sign, no_verify=False):
 658         super(Commit, self).__init__(context)
 659         self.amend = amend
 660         self.msg = msg
 661         self.sign = sign
 662         self.no_verify = no_verify
 663         self.old_commitmsg = self.model.commitmsg
 664         self.new_commitmsg = ''
 665
 666     def do(self):
 667         # Create the commit message file
 668         context = self.context
 669         comment_char = prefs.comment_char(context)
 670         msg = self.strip_comments(self.msg, comment_char=comment_char)
 671         tmp_file = utils.tmp_filename('commit-message')
 672         try:
 673             core.write(tmp_file, msg)
 674             # Run 'git commit'
 675             status, out, err = self.git.commit(
 676                 F=tmp_file,
 677                 v=True,
 678                 gpg_sign=self.sign,
 679                 amend=self.amend,
 680                 no_verify=self.no_verify,
 681             )
 682         finally:
 683             core.unlink(tmp_file)
 684         if status == 0:
 685             super(Commit, self).do()
 686             if context.cfg.get(prefs.AUTOTEMPLATE):
 687                 template_loader = LoadCommitMessageFromTemplate(context)
 688                 template_loader.do()
 689             else:
 690                 self.model.set_commitmsg(self.new_commitmsg)
 691
 692         title = N_('Commit failed')
 693         Interaction.command(title, 'git commit', status, out, err)
 694
 695         return status, out, err
 696
 697     @staticmethod
 698     def strip_comments(msg, comment_char='#'):
 699         # Strip off comments
 700         message_lines = [
 701             line for line in msg.split('\n') if not line.startswith(comment_char)
 702         ]
 703         msg = '\n'.join(message_lines)
 704         if not msg.endswith('\n'):
 705             msg += '\n'
 706
 707         return msg
 708
 709
 710 class CycleReferenceSort(ContextCommand):
 711     """Choose the next reference sort type"""
 712
 713     def do(self):
 714         self.model.cycle_ref_sort()
 715
 716
 717 class Ignore(ContextCommand):
 718     """Add files to an exclusion file"""
 719
 720     def __init__(self, context, filenames, local=False):
 721         super(Ignore, self).__init__(context)
 722         self.filenames = list(filenames)
 723         self.local = local
 724
 725     def do(self):
 726         if not self.filenames:
 727             return
 728         new_additions = '\n'.join(self.filenames) + '\n'
 729         for_status = new_additions
 730         if self.local:
 731             filename = os.path.join('.git', 'info', 'exclude')
 732         else:
 733             filename = '.gitignore'
 734         if core.exists(filename):
 735             current_list = core.read(filename)
 736             new_additions = current_list.rstrip() + '\n' + new_additions
 737         core.write(filename, new_additions)
 738         Interaction.log_status(0, 'Added to %s:\n%s' % (filename, for_status), '')
 739         self.model.update_file_status()
 740
 741
 742 def file_summary(files):
 743     txt = core.list2cmdline(files)
 744     if len(txt) > 768:
 745         txt = txt[:768].rstrip() + '...'
 746     wrap = textwrap.TextWrapper()
 747     return '\n'.join(wrap.wrap(txt))
 748
 749
 750 class RemoteCommand(ConfirmAction):
 751     def __init__(self, context, remote):
 752         super(RemoteCommand, self).__init__(context)
 753         self.remote = remote
 754
 755     def success(self):
 756         self.cfg.reset()
 757         self.model.update_remotes()
 758
 759
 760 class RemoteAdd(RemoteCommand):
 761     def __init__(self, context, remote, url):
 762         super(RemoteAdd, self).__init__(context, remote)
 763         self.url = url
 764
 765     def action(self):
 766         return self.git.remote('add', self.remote, self.url)
 767
 768     def error_message(self):
 769         return N_('Error creating remote "%s"') % self.remote
 770
 771     def command(self):
 772         return 'git remote add "%s" "%s"' % (self.remote, self.url)
 773
 774
 775 class RemoteRemove(RemoteCommand):
 776     def confirm(self):
 777         title = N_('Delete Remote')
 778         question = N_('Delete remote?')
 779         info = N_('Delete remote "%s"') % self.remote
 780         ok_text = N_('Delete')
 781         return Interaction.confirm(title, question, info, ok_text)
 782
 783     def action(self):
 784         return self.git.remote('rm', self.remote)
 785
 786     def error_message(self):
 787         return N_('Error deleting remote "%s"') % self.remote
 788
 789     def command(self):
 790         return 'git remote rm "%s"' % self.remote
 791
 792
 793 class RemoteRename(RemoteCommand):
 794     def __init__(self, context, remote, new_name):
 795         super(RemoteRename, self).__init__(context, remote)
 796         self.new_name = new_name
 797
 798     def confirm(self):
 799         title = N_('Rename Remote')
 800         text = N_('Rename remote "%(current)s" to "%(new)s"?') % dict(
 801             current=self.remote, new=self.new_name
 802         )
 803         info_text = ''
 804         ok_text = title
 805         return Interaction.confirm(title, text, info_text, ok_text)
 806
 807     def action(self):
 808         return self.git.remote('rename', self.remote, self.new_name)
 809
 810     def error_message(self):
 811         return N_('Error renaming "%(name)s" to "%(new_name)s"') % dict(
 812             name=self.remote, new_name=self.new_name
 813         )
 814
 815     def command(self):
 816         return 'git remote rename "%s" "%s"' % (self.remote, self.new_name)
 817
 818
 819 class RemoteSetURL(RemoteCommand):
 820     def __init__(self, context, remote, url):
 821         super(RemoteSetURL, self).__init__(context, remote)
 822         self.url = url
 823
 824     def action(self):
 825         return self.git.remote('set-url', self.remote, self.url)
 826
 827     def error_message(self):
 828         return N_('Unable to set URL for "%(name)s" to "%(url)s"') % dict(
 829             name=self.remote, url=self.url
 830         )
 831
 832     def command(self):
 833         return 'git remote set-url "%s" "%s"' % (self.remote, self.url)
 834
 835
 836 class RemoteEdit(ContextCommand):
 837     """Combine RemoteRename and RemoteSetURL"""
 838
 839     def __init__(self, context, old_name, remote, url):
 840         super(RemoteEdit, self).__init__(context)
 841         self.rename = RemoteRename(context, old_name, remote)
 842         self.set_url = RemoteSetURL(context, remote, url)
 843
 844     def do(self):
 845         result = self.rename.do()
 846         name_ok = result[0]
 847         url_ok = False
 848         if name_ok:
 849             result = self.set_url.do()
 850             url_ok = result[0]
 851         return name_ok, url_ok
 852
 853
 854 class RemoveFromSettings(ConfirmAction):
 855     def __init__(self, context, repo, entry, icon=None):
 856         super(RemoveFromSettings, self).__init__(context)
 857         self.context = context
 858         self.repo = repo
 859         self.entry = entry
 860         self.icon = icon
 861
 862     def success(self):
 863         self.context.settings.save()
 864
 865
 866 class RemoveBookmark(RemoveFromSettings):
 867     def confirm(self):
 868         entry = self.entry
 869         title = msg = N_('Delete Bookmark?')
 870         info = N_('%s will be removed from your bookmarks.') % entry
 871         ok_text = N_('Delete Bookmark')
 872         return Interaction.confirm(title, msg, info, ok_text, icon=self.icon)
 873
 874     def action(self):
 875         self.context.settings.remove_bookmark(self.repo, self.entry)
 876         return (0, '', '')
 877
 878
 879 class RemoveRecent(RemoveFromSettings):
 880     def confirm(self):
 881         repo = self.repo
 882         title = msg = N_('Remove %s from the recent list?') % repo
 883         info = N_('%s will be removed from your recent repositories.') % repo
 884         ok_text = N_('Remove')
 885         return Interaction.confirm(title, msg, info, ok_text, icon=self.icon)
 886
 887     def action(self):
 888         self.context.settings.remove_recent(self.repo)
 889         return (0, '', '')
 890
 891
 892 class RemoveFiles(ContextCommand):
 893     """Removes files"""
 894
 895     def __init__(self, context, remover, filenames):
 896         super(RemoveFiles, self).__init__(context)
 897         if remover is None:
 898             remover = os.remove
 899         self.remover = remover
 900         self.filenames = filenames
 901         # We could git-hash-object stuff and provide undo-ability
 902         # as an option.  Heh.
 903
 904     def do(self):
 905         files = self.filenames
 906         if not files:
 907             return
 908
 909         rescan = False
 910         bad_filenames = []
 911         remove = self.remover
 912         for filename in files:
 913             if filename:
 914                 try:
 915                     remove(filename)
 916                     rescan = True
 917                 except OSError:
 918                     bad_filenames.append(filename)
 919
 920         if bad_filenames:
 921             Interaction.information(
 922                 N_('Error'), N_('Deleting "%s" failed') % file_summary(bad_filenames)
 923             )
 924
 925         if rescan:
 926             self.model.update_file_status()
 927
 928
 929 class Delete(RemoveFiles):
 930     """Delete files."""
 931
 932     def __init__(self, context, filenames):
 933         super(Delete, self).__init__(context, os.remove, filenames)
 934
 935     def do(self):
 936         files = self.filenames
 937         if not files:
 938             return
 939
 940         title = N_('Delete Files?')
 941         msg = N_('The following files will be deleted:') + '\n\n'
 942         msg += file_summary(files)
 943         info_txt = N_('Delete %d file(s)?') % len(files)
 944         ok_txt = N_('Delete Files')
 945
 946         if Interaction.confirm(
 947             title, msg, info_txt, ok_txt, default=True, icon=icons.remove()
 948         ):
 949             super(Delete, self).do()
 950
 951
 952 class MoveToTrash(RemoveFiles):
 953     """Move files to the trash using send2trash"""
 954
 955     AVAILABLE = send2trash is not None
 956
 957     def __init__(self, context, filenames):
 958         super(MoveToTrash, self).__init__(context, send2trash, filenames)
 959
 960
 961 class DeleteBranch(ConfirmAction):
 962     """Delete a git branch."""
 963
 964     def __init__(self, context, branch):
 965         super(DeleteBranch, self).__init__(context)
 966         self.branch = branch
 967
 968     def confirm(self):
 969         title = N_('Delete Branch')
 970         question = N_('Delete branch "%s"?') % self.branch
 971         info = N_('The branch will be no longer available.')
 972         ok_txt = N_('Delete Branch')
 973         return Interaction.confirm(
 974             title, question, info, ok_txt, default=True, icon=icons.discard()
 975         )
 976
 977     def action(self):
 978         return self.model.delete_branch(self.branch)
 979
 980     def error_message(self):
 981         return N_('Error deleting branch "%s"' % self.branch)
 982
 983     def command(self):
 984         command = 'git branch -D %s'
 985         return command % self.branch
 986
 987
 988 class Rename(ContextCommand):
 989     """Rename a set of paths."""
 990
 991     def __init__(self, context, paths):
 992         super(Rename, self).__init__(context)
 993         self.paths = paths
 994
 995     def do(self):
 996         msg = N_('Untracking: %s') % (', '.join(self.paths))
 997         Interaction.log(msg)
 998
 999         for path in self.paths:
1000             ok = self.rename(path)
1001             if not ok:
1002                 return
1003
1004         self.model.update_status()
1005
1006     def rename(self, path):
1007         git = self.git
1008         title = N_('Rename "%s"') % path
1009
1010         if os.path.isdir(path):
1011             base_path = os.path.dirname(path)
1012         else:
1013             base_path = path
1014         new_path = Interaction.save_as(base_path, title)
1015         if not new_path:
1016             return False
1017
1018         status, out, err = git.mv(path, new_path, force=True, verbose=True)
1019         Interaction.command(N_('Error'), 'git mv', status, out, err)
1020         return status == 0
1021
1022
1023 class RenameBranch(ContextCommand):
1024     """Rename a git branch."""
1025
1026     def __init__(self, context, branch, new_branch):
1027         super(RenameBranch, self).__init__(context)
1028         self.branch = branch
1029         self.new_branch = new_branch
1030
1031     def do(self):
1032         branch = self.branch
1033         new_branch = self.new_branch
1034         status, out, err = self.model.rename_branch(branch, new_branch)
1035         Interaction.log_status(status, out, err)
1036
1037
1038 class DeleteRemoteBranch(DeleteBranch):
1039     """Delete a remote git branch."""
1040
1041     def __init__(self, context, remote, branch):
1042         super(DeleteRemoteBranch, self).__init__(context, branch)
1043         self.remote = remote
1044
1045     def action(self):
1046         return self.git.push(self.remote, self.branch, delete=True)
1047
1048     def success(self):
1049         self.model.update_status()
1050         Interaction.information(
1051             N_('Remote Branch Deleted'),
1052             N_('"%(branch)s" has been deleted from "%(remote)s".')
1053             % dict(branch=self.branch, remote=self.remote),
1054         )
1055
1056     def error_message(self):
1057         return N_('Error Deleting Remote Branch')
1058
1059     def command(self):
1060         command = 'git push --delete %s %s'
1061         return command % (self.remote, self.branch)
1062
1063
1064 def get_mode(model, staged, modified, unmerged, untracked):
1065     if staged:
1066         mode = model.mode_index
1067     elif modified or unmerged:
1068         mode = model.mode_worktree
1069     elif untracked:
1070         mode = model.mode_untracked
1071     else:
1072         mode = model.mode
1073     return mode
1074
1075
1076 class DiffText(EditModel):
1077     """Set the diff type to text"""
1078
1079     def __init__(self, context):
1080         super(DiffText, self).__init__(context)
1081         self.new_file_type = main.Types.TEXT
1082         self.new_diff_type = main.Types.TEXT
1083
1084
1085 class ToggleDiffType(ContextCommand):
1086     """Toggle the diff type between image and text"""
1087
1088     def __init__(self, context):
1089         super(ToggleDiffType, self).__init__(context)
1090         if self.model.diff_type == main.Types.IMAGE:
1091             self.new_diff_type = main.Types.TEXT
1092             self.new_value = False
1093         else:
1094             self.new_diff_type = main.Types.IMAGE
1095             self.new_value = True
1096
1097     def do(self):
1098         diff_type = self.new_diff_type
1099         value = self.new_value
1100
1101         self.model.set_diff_type(diff_type)
1102
1103         filename = self.model.filename
1104         _, ext = os.path.splitext(filename)
1105         if ext.startswith('.'):
1106             cfg = 'cola.imagediff' + ext
1107             self.cfg.set_repo(cfg, value)
1108
1109
1110 class DiffImage(EditModel):
1111     def __init__(
1112         self, context, filename, deleted, staged, modified, unmerged, untracked
1113     ):
1114         super(DiffImage, self).__init__(context)
1115
1116         self.new_filename = filename
1117         self.new_diff_type = self.get_diff_type(filename)
1118         self.new_file_type = main.Types.IMAGE
1119         self.new_mode = get_mode(self.model, staged, modified, unmerged, untracked)
1120         self.staged = staged
1121         self.modified = modified
1122         self.unmerged = unmerged
1123         self.untracked = untracked
1124         self.deleted = deleted
1125         self.annex = self.cfg.is_annex()
1126
1127     def get_diff_type(self, filename):
1128         """Query the diff type to use based on cola.imagediff.<extension>"""
1129         _, ext = os.path.splitext(filename)
1130         if ext.startswith('.'):
1131             # Check eg. "cola.imagediff.svg" to see if we should imagediff.
1132             cfg = 'cola.imagediff' + ext
1133             if self.cfg.get(cfg, True):
1134                 result = main.Types.IMAGE
1135             else:
1136                 result = main.Types.TEXT
1137         else:
1138             result = main.Types.IMAGE
1139         return result
1140
1141     def do(self):
1142         filename = self.new_filename
1143
1144         if self.staged:
1145             images = self.staged_images()
1146         elif self.modified:
1147             images = self.modified_images()
1148         elif self.unmerged:
1149             images = self.unmerged_images()
1150         elif self.untracked:
1151             images = [(filename, False)]
1152         else:
1153             images = []
1154
1155         self.model.set_images(images)
1156         super(DiffImage, self).do()
1157
1158     def staged_images(self):
1159         context = self.context
1160         git = self.git
1161         head = self.model.head
1162         filename = self.new_filename
1163         annex = self.annex
1164
1165         images = []
1166         index = git.diff_index(head, '--', filename, cached=True)[STDOUT]
1167         if index:
1168             # Example:
1169             #  :100644 100644 fabadb8... 4866510... M      describe.c
1170             parts = index.split(' ')
1171             if len(parts) > 3:
1172                 old_oid = parts[2]
1173                 new_oid = parts[3]
1174
1175             if old_oid != MISSING_BLOB_OID:
1176                 # First, check if we can get a pre-image from git-annex
1177                 annex_image = None
1178                 if annex:
1179                     annex_image = gitcmds.annex_path(context, head, filename)
1180                 if annex_image:
1181                     images.append((annex_image, False))  # git annex HEAD
1182                 else:
1183                     image = gitcmds.write_blob_path(context, head, old_oid, filename)
1184                     if image:
1185                         images.append((image, True))
1186
1187             if new_oid != MISSING_BLOB_OID:
1188                 found_in_annex = False
1189                 if annex and core.islink(filename):
1190                     status, out, _ = git.annex('status', '--', filename)
1191                     if status == 0:
1192                         details = out.split(' ')
1193                         if details and details[0] == 'A':  # newly added file
1194                             images.append((filename, False))
1195                             found_in_annex = True
1196
1197                 if not found_in_annex:
1198                     image = gitcmds.write_blob(context, new_oid, filename)
1199                     if image:
1200                         images.append((image, True))
1201
1202         return images
1203
1204     def unmerged_images(self):
1205         context = self.context
1206         git = self.git
1207         head = self.model.head
1208         filename = self.new_filename
1209         annex = self.annex
1210
1211         candidate_merge_heads = ('HEAD', 'CHERRY_HEAD', 'MERGE_HEAD')
1212         merge_heads = [
1213             merge_head
1214             for merge_head in candidate_merge_heads
1215             if core.exists(git.git_path(merge_head))
1216         ]
1217
1218         if annex:  # Attempt to find files in git-annex
1219             annex_images = []
1220             for merge_head in merge_heads:
1221                 image = gitcmds.annex_path(context, merge_head, filename)
1222                 if image:
1223                     annex_images.append((image, False))
1224             if annex_images:
1225                 annex_images.append((filename, False))
1226                 return annex_images
1227
1228         # DIFF FORMAT FOR MERGES
1229         # "git-diff-tree", "git-diff-files" and "git-diff --raw"
1230         # can take -c or --cc option to generate diff output also
1231         # for merge commits. The output differs from the format
1232         # described above in the following way:
1233         #
1234         #  1. there is a colon for each parent
1235         #  2. there are more "src" modes and "src" sha1
1236         #  3. status is concatenated status characters for each parent
1237         #  4. no optional "score" number
1238         #  5. single path, only for "dst"
1239         # Example:
1240         #  ::100644 100644 100644 fabadb8... cc95eb0... 4866510... \
1241         #  MM      describe.c
1242         images = []
1243         index = git.diff_index(head, '--', filename, cached=True, cc=True)[STDOUT]
1244         if index:
1245             parts = index.split(' ')
1246             if len(parts) > 3:
1247                 first_mode = parts[0]
1248                 num_parents = first_mode.count(':')
1249                 # colon for each parent, but for the index, the "parents"
1250                 # are really entries in stages 1,2,3 (head, base, remote)
1251                 # remote, base, head
1252                 for i in range(num_parents):
1253                     offset = num_parents + i + 1
1254                     oid = parts[offset]
1255                     try:
1256                         merge_head = merge_heads[i]
1257                     except IndexError:
1258                         merge_head = 'HEAD'
1259                     if oid != MISSING_BLOB_OID:
1260                         image = gitcmds.write_blob_path(
1261                             context, merge_head, oid, filename
1262                         )
1263                         if image:
1264                             images.append((image, True))
1265
1266         images.append((filename, False))
1267         return images
1268
1269     def modified_images(self):
1270         context = self.context
1271         git = self.git
1272         head = self.model.head
1273         filename = self.new_filename
1274         annex = self.annex
1275
1276         images = []
1277         annex_image = None
1278         if annex:  # Check for a pre-image from git-annex
1279             annex_image = gitcmds.annex_path(context, head, filename)
1280         if annex_image:
1281             images.append((annex_image, False))  # git annex HEAD
1282         else:
1283             worktree = git.diff_files('--', filename)[STDOUT]
1284             parts = worktree.split(' ')
1285             if len(parts) > 3:
1286                 oid = parts[2]
1287                 if oid != MISSING_BLOB_OID:
1288                     image = gitcmds.write_blob_path(context, head, oid, filename)
1289                     if image:
1290                         images.append((image, True))  # HEAD
1291
1292         images.append((filename, False))  # worktree
1293         return images
1294
1295
1296 class Diff(EditModel):
1297     """Perform a diff and set the model's current text."""
1298
1299     def __init__(self, context, filename, cached=False, deleted=False):
1300         super(Diff, self).__init__(context)
1301         opts = {}
1302         if cached:
1303             opts['ref'] = self.model.head
1304         self.new_filename = filename
1305         self.new_mode = self.model.mode_worktree
1306         self.new_diff_text = gitcmds.diff_helper(
1307             self.context, filename=filename, cached=cached, deleted=deleted, **opts
1308         )
1309
1310
1311 class Diffstat(EditModel):
1312     """Perform a diffstat and set the model's diff text."""
1313
1314     def __init__(self, context):
1315         super(Diffstat, self).__init__(context)
1316         cfg = self.cfg
1317         diff_context = cfg.get('diff.context', 3)
1318         diff = self.git.diff(
1319             self.model.head,
1320             unified=diff_context,
1321             no_ext_diff=True,
1322             no_color=True,
1323             M=True,
1324             stat=True,
1325         )[STDOUT]
1326         self.new_diff_text = diff
1327         self.new_diff_type = main.Types.TEXT
1328         self.new_file_type = main.Types.TEXT
1329         self.new_mode = self.model.mode_diffstat
1330
1331
1332 class DiffStaged(Diff):
1333     """Perform a staged diff on a file."""
1334
1335     def __init__(self, context, filename, deleted=None):
1336         super(DiffStaged, self).__init__(
1337             context, filename, cached=True, deleted=deleted
1338         )
1339         self.new_mode = self.model.mode_index
1340
1341
1342 class DiffStagedSummary(EditModel):
1343     def __init__(self, context):
1344         super(DiffStagedSummary, self).__init__(context)
1345         diff = self.git.diff(
1346             self.model.head,
1347             cached=True,
1348             no_color=True,
1349             no_ext_diff=True,
1350             patch_with_stat=True,
1351             M=True,
1352         )[STDOUT]
1353         self.new_diff_text = diff
1354         self.new_diff_type = main.Types.TEXT
1355         self.new_file_type = main.Types.TEXT
1356         self.new_mode = self.model.mode_index
1357
1358
1359 class Difftool(ContextCommand):
1360     """Run git-difftool limited by path."""
1361
1362     def __init__(self, context, staged, filenames):
1363         super(Difftool, self).__init__(context)
1364         self.staged = staged
1365         self.filenames = filenames
1366
1367     def do(self):
1368         difftool_launch_with_head(
1369             self.context, self.filenames, self.staged, self.model.head
1370         )
1371
1372
1373 class Edit(ContextCommand):
1374     """Edit a file using the configured gui.editor."""
1375
1376     @staticmethod
1377     def name():
1378         return N_('Launch Editor')
1379
1380     def __init__(self, context, filenames, line_number=None, background_editor=False):
1381         super(Edit, self).__init__(context)
1382         self.filenames = filenames
1383         self.line_number = line_number
1384         self.background_editor = background_editor
1385
1386     def do(self):
1387         context = self.context
1388         if not self.filenames:
1389             return
1390         filename = self.filenames[0]
1391         if not core.exists(filename):
1392             return
1393         if self.background_editor:
1394             editor = prefs.background_editor(context)
1395         else:
1396             editor = prefs.editor(context)
1397         opts = []
1398
1399         if self.line_number is None:
1400             opts = self.filenames
1401         else:
1402             # Single-file w/ line-numbers (likely from grep)
1403             editor_opts = {
1404                 '*vim*': [filename, '+%s' % self.line_number],
1405                 '*emacs*': ['+%s' % self.line_number, filename],
1406                 '*textpad*': ['%s(%s,0)' % (filename, self.line_number)],
1407                 '*notepad++*': ['-n%s' % self.line_number, filename],
1408                 '*subl*': ['%s:%s' % (filename, self.line_number)],
1409             }
1410
1411             opts = self.filenames
1412             for pattern, opt in editor_opts.items():
1413                 if fnmatch(editor, pattern):
1414                     opts = opt
1415                     break
1416
1417         try:
1418             core.fork(utils.shell_split(editor) + opts)
1419         except (OSError, ValueError) as e:
1420             message = N_('Cannot exec "%s": please configure your editor') % editor
1421             _, details = utils.format_exception(e)
1422             Interaction.critical(N_('Error Editing File'), message, details)
1423
1424
1425 class FormatPatch(ContextCommand):
1426     """Output a patch series given all revisions and a selected subset."""
1427
1428     def __init__(self, context, to_export, revs, output='patches'):
1429         super(FormatPatch, self).__init__(context)
1430         self.to_export = list(to_export)
1431         self.revs = list(revs)
1432         self.output = output
1433
1434     def do(self):
1435         context = self.context
1436         status, out, err = gitcmds.format_patchsets(
1437             context, self.to_export, self.revs, self.output
1438         )
1439         Interaction.log_status(status, out, err)
1440
1441
1442 class LaunchDifftool(ContextCommand):
1443     @staticmethod
1444     def name():
1445         return N_('Launch Diff Tool')
1446
1447     def do(self):
1448         s = self.selection.selection()
1449         if s.unmerged:
1450             paths = s.unmerged
1451             if utils.is_win32():
1452                 core.fork(['git', 'mergetool', '--no-prompt', '--'] + paths)
1453             else:
1454                 cfg = self.cfg
1455                 cmd = cfg.terminal()
1456                 argv = utils.shell_split(cmd)
1457
1458                 terminal = os.path.basename(argv[0])
1459                 shellquote_terms = set(['xfce4-terminal'])
1460                 shellquote_default = terminal in shellquote_terms
1461
1462                 mergetool = ['git', 'mergetool', '--no-prompt', '--']
1463                 mergetool.extend(paths)
1464                 needs_shellquote = cfg.get(
1465                     'cola.terminalshellquote', shellquote_default
1466                 )
1467
1468                 if needs_shellquote:
1469                     argv.append(core.list2cmdline(mergetool))
1470                 else:
1471                     argv.extend(mergetool)
1472
1473                 core.fork(argv)
1474         else:
1475             difftool_run(self.context)
1476
1477
1478 class LaunchTerminal(ContextCommand):
1479     @staticmethod
1480     def name():
1481         return N_('Launch Terminal')
1482
1483     @staticmethod
1484     def is_available(context):
1485         return context.cfg.terminal() is not None
1486
1487     def __init__(self, context, path):
1488         super(LaunchTerminal, self).__init__(context)
1489         self.path = path
1490
1491     def do(self):
1492         cmd = self.context.cfg.terminal()
1493         if cmd is None:
1494             return
1495         if utils.is_win32():
1496             argv = ['start', '', cmd, '--login']
1497             shell = True
1498         else:
1499             argv = utils.shell_split(cmd)
1500             argv.append(os.getenv('SHELL', '/bin/sh'))
1501             shell = False
1502         core.fork(argv, cwd=self.path, shell=shell)
1503
1504
1505 class LaunchEditor(Edit):
1506     @staticmethod
1507     def name():
1508         return N_('Launch Editor')
1509
1510     def __init__(self, context):
1511         s = context.selection.selection()
1512         filenames = s.staged + s.unmerged + s.modified + s.untracked
1513         super(LaunchEditor, self).__init__(context, filenames, background_editor=True)
1514
1515
1516 class LaunchEditorAtLine(LaunchEditor):
1517     """Launch an editor at the specified line"""
1518
1519     def __init__(self, context):
1520         super(LaunchEditorAtLine, self).__init__(context)
1521         self.line_number = context.selection.line_number
1522
1523
1524 class LoadCommitMessageFromFile(ContextCommand):
1525     """Loads a commit message from a path."""
1526
1527     UNDOABLE = True
1528
1529     def __init__(self, context, path):
1530         super(LoadCommitMessageFromFile, self).__init__(context)
1531         self.path = path
1532         self.old_commitmsg = self.model.commitmsg
1533         self.old_directory = self.model.directory
1534
1535     def do(self):
1536         path = os.path.expanduser(self.path)
1537         if not path or not core.isfile(path):
1538             raise UsageError(
1539                 N_('Error: Cannot find commit template'),
1540                 N_('%s: No such file or directory.') % path,
1541             )
1542         self.model.set_directory(os.path.dirname(path))
1543         self.model.set_commitmsg(core.read(path))
1544
1545     def undo(self):
1546         self.model.set_commitmsg(self.old_commitmsg)
1547         self.model.set_directory(self.old_directory)
1548
1549
1550 class LoadCommitMessageFromTemplate(LoadCommitMessageFromFile):
1551     """Loads the commit message template specified by commit.template."""
1552
1553     def __init__(self, context):
1554         cfg = context.cfg
1555         template = cfg.get('commit.template')
1556         super(LoadCommitMessageFromTemplate, self).__init__(context, template)
1557
1558     def do(self):
1559         if self.path is None:
1560             raise UsageError(
1561                 N_('Error: Unconfigured commit template'),
1562                 N_(
1563                     'A commit template has not been configured.\n'
1564                     'Use "git config" to define "commit.template"\n'
1565                     'so that it points to a commit template.'
1566                 ),
1567             )
1568         return LoadCommitMessageFromFile.do(self)
1569
1570
1571 class LoadCommitMessageFromOID(ContextCommand):
1572     """Load a previous commit message"""
1573
1574     UNDOABLE = True
1575
1576     def __init__(self, context, oid, prefix=''):
1577         super(LoadCommitMessageFromOID, self).__init__(context)
1578         self.oid = oid
1579         self.old_commitmsg = self.model.commitmsg
1580         self.new_commitmsg = prefix + gitcmds.prev_commitmsg(context, oid)
1581
1582     def do(self):
1583         self.model.set_commitmsg(self.new_commitmsg)
1584
1585     def undo(self):
1586         self.model.set_commitmsg(self.old_commitmsg)
1587
1588
1589 class PrepareCommitMessageHook(ContextCommand):
1590     """Use the cola-prepare-commit-msg hook to prepare the commit message"""
1591
1592     UNDOABLE = True
1593
1594     def __init__(self, context):
1595         super(PrepareCommitMessageHook, self).__init__(context)
1596         self.old_commitmsg = self.model.commitmsg
1597
1598     def get_message(self):
1599
1600         title = N_('Error running prepare-commitmsg hook')
1601         hook = gitcmds.prepare_commit_message_hook(self.context)
1602
1603         if os.path.exists(hook):
1604             filename = self.model.save_commitmsg()
1605             status, out, err = core.run_command([hook, filename])
1606
1607             if status == 0:
1608                 result = core.read(filename)
1609             else:
1610                 result = self.old_commitmsg
1611                 Interaction.command_error(title, hook, status, out, err)
1612         else:
1613             message = N_('A hook must be provided at "%s"') % hook
1614             Interaction.critical(title, message=message)
1615             result = self.old_commitmsg
1616
1617         return result
1618
1619     def do(self):
1620         msg = self.get_message()
1621         self.model.set_commitmsg(msg)
1622
1623     def undo(self):
1624         self.model.set_commitmsg(self.old_commitmsg)
1625
1626
1627 class LoadFixupMessage(LoadCommitMessageFromOID):
1628     """Load a fixup message"""
1629
1630     def __init__(self, context, oid):
1631         super(LoadFixupMessage, self).__init__(context, oid, prefix='fixup! ')
1632         if self.new_commitmsg:
1633             self.new_commitmsg = self.new_commitmsg.splitlines()[0]
1634
1635
1636 class Merge(ContextCommand):
1637     """Merge commits"""
1638
1639     def __init__(self, context, revision, no_commit, squash, no_ff, sign):
1640         super(Merge, self).__init__(context)
1641         self.revision = revision
1642         self.no_ff = no_ff
1643         self.no_commit = no_commit
1644         self.squash = squash
1645         self.sign = sign
1646
1647     def do(self):
1648         squash = self.squash
1649         revision = self.revision
1650         no_ff = self.no_ff
1651         no_commit = self.no_commit
1652         sign = self.sign
1653
1654         status, out, err = self.git.merge(
1655             revision, gpg_sign=sign, no_ff=no_ff, no_commit=no_commit, squash=squash
1656         )
1657         self.model.update_status()
1658         title = N_('Merge failed.  Conflict resolution is required.')
1659         Interaction.command(title, 'git merge', status, out, err)
1660
1661         return status, out, err
1662
1663
1664 class OpenDefaultApp(ContextCommand):
1665     """Open a file using the OS default."""
1666
1667     @staticmethod
1668     def name():
1669         return N_('Open Using Default Application')
1670
1671     def __init__(self, context, filenames):
1672         super(OpenDefaultApp, self).__init__(context)
1673         if utils.is_darwin():
1674             launcher = 'open'
1675         else:
1676             launcher = 'xdg-open'
1677         self.launcher = launcher
1678         self.filenames = filenames
1679
1680     def do(self):
1681         if not self.filenames:
1682             return
1683         core.fork([self.launcher] + self.filenames)
1684
1685
1686 class OpenParentDir(OpenDefaultApp):
1687     """Open parent directories using the OS default."""
1688
1689     @staticmethod
1690     def name():
1691         return N_('Open Parent Directory')
1692
1693     def __init__(self, context, filenames):
1694         OpenDefaultApp.__init__(self, context, filenames)
1695
1696     def do(self):
1697         if not self.filenames:
1698             return
1699         dirnames = list(set([os.path.dirname(x) for x in self.filenames]))
1700         # os.path.dirname() can return an empty string so we fallback to
1701         # the current directory
1702         dirs = [(dirname or core.getcwd()) for dirname in dirnames]
1703         core.fork([self.launcher] + dirs)
1704
1705
1706 class OpenNewRepo(ContextCommand):
1707     """Launches git-cola on a repo."""
1708
1709     def __init__(self, context, repo_path):
1710         super(OpenNewRepo, self).__init__(context)
1711         self.repo_path = repo_path
1712
1713     def do(self):
1714         self.model.set_directory(self.repo_path)
1715         core.fork([sys.executable, sys.argv[0], '--repo', self.repo_path])
1716
1717
1718 class OpenRepo(EditModel):
1719     def __init__(self, context, repo_path):
1720         super(OpenRepo, self).__init__(context)
1721         self.repo_path = repo_path
1722         self.new_mode = self.model.mode_none
1723         self.new_diff_text = ''
1724         self.new_diff_type = main.Types.TEXT
1725         self.new_file_type = main.Types.TEXT
1726         self.new_commitmsg = ''
1727         self.new_filename = ''
1728
1729     def do(self):
1730         old_repo = self.git.getcwd()
1731         if self.model.set_worktree(self.repo_path):
1732             self.fsmonitor.stop()
1733             self.fsmonitor.start()
1734             self.model.update_status()
1735             # Check if template should be loaded
1736             if self.context.cfg.get(prefs.AUTOTEMPLATE):
1737                 template_loader = LoadCommitMessageFromTemplate(self.context)
1738                 template_loader.do()
1739             else:
1740                 self.model.set_commitmsg(self.new_commitmsg)
1741             settings = self.context.settings
1742             settings.load()
1743             settings.add_recent(self.repo_path, prefs.maxrecent(self.context))
1744             settings.save()
1745             super(OpenRepo, self).do()
1746         else:
1747             self.model.set_worktree(old_repo)
1748
1749
1750 class OpenParentRepo(OpenRepo):
1751     def __init__(self, context):
1752         path = ''
1753         if version.check_git(context, 'show-superproject-working-tree'):
1754             status, out, _ = context.git.rev_parse(show_superproject_working_tree=True)
1755             if status == 0:
1756                 path = out
1757         if not path:
1758             path = os.path.dirname(core.getcwd())
1759         super(OpenParentRepo, self).__init__(context, path)
1760
1761
1762 class Clone(ContextCommand):
1763     """Clones a repository and optionally spawns a new cola session."""
1764
1765     def __init__(
1766         self, context, url, new_directory, submodules=False, shallow=False, spawn=True
1767     ):
1768         super(Clone, self).__init__(context)
1769         self.url = url
1770         self.new_directory = new_directory
1771         self.submodules = submodules
1772         self.shallow = shallow
1773         self.spawn = spawn
1774         self.status = -1
1775         self.out = ''
1776         self.err = ''
1777
1778     def do(self):
1779         kwargs = {}
1780         if self.shallow:
1781             kwargs['depth'] = 1
1782         recurse_submodules = self.submodules
1783         shallow_submodules = self.submodules and self.shallow
1784
1785         status, out, err = self.git.clone(
1786             self.url,
1787             self.new_directory,
1788             recurse_submodules=recurse_submodules,
1789             shallow_submodules=shallow_submodules,
1790             **kwargs
1791         )
1792
1793         self.status = status
1794         self.out = out
1795         self.err = err
1796         if status == 0 and self.spawn:
1797             executable = sys.executable
1798             core.fork([executable, sys.argv[0], '--repo', self.new_directory])
1799         return self
1800
1801
1802 class NewBareRepo(ContextCommand):
1803     """Create a new shared bare repository"""
1804
1805     def __init__(self, context, path):
1806         super(NewBareRepo, self).__init__(context)
1807         self.path = path
1808
1809     def do(self):
1810         path = self.path
1811         status, out, err = self.git.init(path, bare=True, shared=True)
1812         Interaction.command(
1813             N_('Error'), 'git init --bare --shared "%s"' % path, status, out, err
1814         )
1815         return status == 0
1816
1817
1818 def unix_path(path, is_win32=utils.is_win32):
1819     """Git for Windows requires unix paths, so force them here"""
1820     if is_win32():
1821         path = path.replace('\\', '/')
1822         first = path[0]
1823         second = path[1]
1824         if second == ':':  # sanity check, this better be a Windows-style path
1825             path = '/' + first + path[2:]
1826
1827     return path
1828
1829
1830 def sequence_editor():
1831     """Set GIT_SEQUENCE_EDITOR for running git-cola-sequence-editor"""
1832     xbase = unix_path(resources.command('git-cola-sequence-editor'))
1833     editor = core.list2cmdline([unix_path(sys.executable), xbase])
1834     return editor
1835
1836
1837 class SequenceEditorEnvironment(object):
1838     """Set environment variables to enable git-cola-sequence-editor"""
1839
1840     def __init__(self, context, **kwargs):
1841         self.env = {
1842             'GIT_EDITOR': prefs.editor(context),
1843             'GIT_SEQUENCE_EDITOR': sequence_editor(),
1844             'GIT_COLA_SEQ_EDITOR_CANCEL_ACTION': 'save',
1845         }
1846         self.env.update(kwargs)
1847
1848     def __enter__(self):
1849         for var, value in self.env.items():
1850             compat.setenv(var, value)
1851         return self
1852
1853     def __exit__(self, exc_type, exc_val, exc_tb):
1854         for var in self.env:
1855             compat.unsetenv(var)
1856
1857
1858 class Rebase(ContextCommand):
1859     def __init__(self, context, upstream=None, branch=None, **kwargs):
1860         """Start an interactive rebase session
1861
1862         :param upstream: upstream branch
1863         :param branch: optional branch to checkout
1864         :param kwargs: forwarded directly to `git.rebase()`
1865
1866         """
1867         super(Rebase, self).__init__(context)
1868
1869         self.upstream = upstream
1870         self.branch = branch
1871         self.kwargs = kwargs
1872
1873     def prepare_arguments(self, upstream):
1874         args = []
1875         kwargs = {}
1876
1877         # Rebase actions must be the only option specified
1878         for action in ('continue', 'abort', 'skip', 'edit_todo'):
1879             if self.kwargs.get(action, False):
1880                 kwargs[action] = self.kwargs[action]
1881                 return args, kwargs
1882
1883         kwargs['interactive'] = True
1884         kwargs['autosquash'] = self.kwargs.get('autosquash', True)
1885         kwargs.update(self.kwargs)
1886
1887         if upstream:
1888             args.append(upstream)
1889         if self.branch:
1890             args.append(self.branch)
1891
1892         return args, kwargs
1893
1894     def do(self):
1895         (status, out, err) = (1, '', '')
1896         context = self.context
1897         cfg = self.cfg
1898         model = self.model
1899
1900         if not cfg.get('rebase.autostash', False):
1901             if model.staged or model.unmerged or model.modified:
1902                 Interaction.information(
1903                     N_('Unable to rebase'),
1904                     N_('You cannot rebase with uncommitted changes.'),
1905                 )
1906                 return status, out, err
1907
1908         upstream = self.upstream or Interaction.choose_ref(
1909             context,
1910             N_('Select New Upstream'),
1911             N_('Interactive Rebase'),
1912             default='@{upstream}',
1913         )
1914         if not upstream:
1915             return status, out, err
1916
1917         self.model.is_rebasing = True
1918         self.model.emit_updated()
1919
1920         args, kwargs = self.prepare_arguments(upstream)
1921         upstream_title = upstream or '@{upstream}'
1922         with SequenceEditorEnvironment(
1923             self.context,
1924             GIT_COLA_SEQ_EDITOR_TITLE=N_('Rebase onto %s') % upstream_title,
1925             GIT_COLA_SEQ_EDITOR_ACTION=N_('Rebase'),
1926         ):
1927             # TODO this blocks the user interface window for the duration
1928             # of git-cola-sequence-editor. We would need to implement
1929             # signals for QProcess and continue running the main thread.
1930             # Alternatively, we can hide the main window while rebasing.
1931             # That doesn't require as much effort.
1932             status, out, err = self.git.rebase(
1933                 *args, _no_win32_startupinfo=True, **kwargs
1934             )
1935         self.model.update_status()
1936         if err.strip() != 'Nothing to do':
1937             title = N_('Rebase stopped')
1938             Interaction.command(title, 'git rebase', status, out, err)
1939         return status, out, err
1940
1941
1942 class RebaseEditTodo(ContextCommand):
1943     def do(self):
1944         (status, out, err) = (1, '', '')
1945         with SequenceEditorEnvironment(
1946             self.context,
1947             GIT_COLA_SEQ_EDITOR_TITLE=N_('Edit Rebase'),
1948             GIT_COLA_SEQ_EDITOR_ACTION=N_('Save'),
1949         ):
1950             status, out, err = self.git.rebase(edit_todo=True)
1951         Interaction.log_status(status, out, err)
1952         self.model.update_status()
1953         return status, out, err
1954
1955
1956 class RebaseContinue(ContextCommand):
1957     def do(self):
1958         (status, out, err) = (1, '', '')
1959         with SequenceEditorEnvironment(
1960             self.context,
1961             GIT_COLA_SEQ_EDITOR_TITLE=N_('Rebase'),
1962             GIT_COLA_SEQ_EDITOR_ACTION=N_('Rebase'),
1963         ):
1964             status, out, err = self.git.rebase('--continue')
1965         Interaction.log_status(status, out, err)
1966         self.model.update_status()
1967         return status, out, err
1968
1969
1970 class RebaseSkip(ContextCommand):
1971     def do(self):
1972         (status, out, err) = (1, '', '')
1973         with SequenceEditorEnvironment(
1974             self.context,
1975             GIT_COLA_SEQ_EDITOR_TITLE=N_('Rebase'),
1976             GIT_COLA_SEQ_EDITOR_ACTION=N_('Rebase'),
1977         ):
1978             status, out, err = self.git.rebase(skip=True)
1979         Interaction.log_status(status, out, err)
1980         self.model.update_status()
1981         return status, out, err
1982
1983
1984 class RebaseAbort(ContextCommand):
1985     def do(self):
1986         status, out, err = self.git.rebase(abort=True)
1987         Interaction.log_status(status, out, err)
1988         self.model.update_status()
1989
1990
1991 class Rescan(ContextCommand):
1992     """Rescan for changes"""
1993
1994     def do(self):
1995         self.model.update_status()
1996
1997
1998 class Refresh(ContextCommand):
1999     """Update refs, refresh the index, and update config"""
2000
2001     @staticmethod
2002     def name():
2003         return N_('Refresh')
2004
2005     def do(self):
2006         self.model.update_status(update_index=True)
2007         self.cfg.update()
2008         self.fsmonitor.refresh()
2009
2010
2011 class RefreshConfig(ContextCommand):
2012     """Refresh the git config cache"""
2013
2014     def do(self):
2015         self.cfg.update()
2016
2017
2018 class RevertEditsCommand(ConfirmAction):
2019     def __init__(self, context):
2020         super(RevertEditsCommand, self).__init__(context)
2021         self.icon = icons.undo()
2022
2023     def ok_to_run(self):
2024         return self.model.undoable()
2025
2026     # pylint: disable=no-self-use
2027     def checkout_from_head(self):
2028         return False
2029
2030     def checkout_args(self):
2031         args = []
2032         s = self.selection.selection()
2033         if self.checkout_from_head():
2034             args.append(self.model.head)
2035         args.append('--')
2036
2037         if s.staged:
2038             items = s.staged
2039         else:
2040             items = s.modified
2041         args.extend(items)
2042
2043         return args
2044
2045     def action(self):
2046         checkout_args = self.checkout_args()
2047         return self.git.checkout(*checkout_args)
2048
2049     def success(self):
2050         self.model.set_diff_type(main.Types.TEXT)
2051         self.model.update_file_status()
2052
2053
2054 class RevertUnstagedEdits(RevertEditsCommand):
2055     @staticmethod
2056     def name():
2057         return N_('Revert Unstaged Edits...')
2058
2059     def checkout_from_head(self):
2060         # Being in amend mode should not affect the behavior of this command.
2061         # The only sensible thing to do is to checkout from the index.
2062         return False
2063
2064     def confirm(self):
2065         title = N_('Revert Unstaged Changes?')
2066         text = N_(
2067             'This operation removes unstaged edits from selected files.\n'
2068             'These changes cannot be recovered.'
2069         )
2070         info = N_('Revert the unstaged changes?')
2071         ok_text = N_('Revert Unstaged Changes')
2072         return Interaction.confirm(
2073             title, text, info, ok_text, default=True, icon=self.icon
2074         )
2075
2076
2077 class RevertUncommittedEdits(RevertEditsCommand):
2078     @staticmethod
2079     def name():
2080         return N_('Revert Uncommitted Edits...')
2081
2082     def checkout_from_head(self):
2083         return True
2084
2085     def confirm(self):
2086         """Prompt for reverting changes"""
2087         title = N_('Revert Uncommitted Changes?')
2088         text = N_(
2089             'This operation removes uncommitted edits from selected files.\n'
2090             'These changes cannot be recovered.'
2091         )
2092         info = N_('Revert the uncommitted changes?')
2093         ok_text = N_('Revert Uncommitted Changes')
2094         return Interaction.confirm(
2095             title, text, info, ok_text, default=True, icon=self.icon
2096         )
2097
2098
2099 class RunConfigAction(ContextCommand):
2100     """Run a user-configured action, typically from the "Tools" menu"""
2101
2102     def __init__(self, context, action_name):
2103         super(RunConfigAction, self).__init__(context)
2104         self.action_name = action_name
2105
2106     def do(self):
2107         """Run the user-configured action"""
2108         for env in ('ARGS', 'DIRNAME', 'FILENAME', 'REVISION'):
2109             try:
2110                 compat.unsetenv(env)
2111             except KeyError:
2112                 pass
2113         rev = None
2114         args = None
2115         context = self.context
2116         cfg = self.cfg
2117         opts = cfg.get_guitool_opts(self.action_name)
2118         cmd = opts.get('cmd')
2119         if 'title' not in opts:
2120             opts['title'] = cmd
2121
2122         if 'prompt' not in opts or opts.get('prompt') is True:
2123             prompt = N_('Run "%s"?') % cmd
2124             opts['prompt'] = prompt
2125
2126         if opts.get('needsfile'):
2127             filename = self.selection.filename()
2128             if not filename:
2129                 Interaction.information(
2130                     N_('Please select a file'),
2131                     N_('"%s" requires a selected file.') % cmd,
2132                 )
2133                 return False
2134             dirname = utils.dirname(filename, current_dir='.')
2135             compat.setenv('FILENAME', filename)
2136             compat.setenv('DIRNAME', dirname)
2137
2138         if opts.get('revprompt') or opts.get('argprompt'):
2139             while True:
2140                 ok = Interaction.confirm_config_action(context, cmd, opts)
2141                 if not ok:
2142                     return False
2143                 rev = opts.get('revision')
2144                 args = opts.get('args')
2145                 if opts.get('revprompt') and not rev:
2146                     title = N_('Invalid Revision')
2147                     msg = N_('The revision expression cannot be empty.')
2148                     Interaction.critical(title, msg)
2149                     continue
2150                 break
2151
2152         elif opts.get('confirm'):
2153             title = os.path.expandvars(opts.get('title'))
2154             prompt = os.path.expandvars(opts.get('prompt'))
2155             if not Interaction.question(title, prompt):
2156                 return False
2157         if rev:
2158             compat.setenv('REVISION', rev)
2159         if args:
2160             compat.setenv('ARGS', args)
2161         title = os.path.expandvars(cmd)
2162         Interaction.log(N_('Running command: %s') % title)
2163         cmd = ['sh', '-c', cmd]
2164
2165         if opts.get('background'):
2166             core.fork(cmd)
2167             status, out, err = (0, '', '')
2168         elif opts.get('noconsole'):
2169             status, out, err = core.run_command(cmd)
2170         else:
2171             status, out, err = Interaction.run_command(title, cmd)
2172
2173         if not opts.get('background') and not opts.get('norescan'):
2174             self.model.update_status()
2175
2176         title = N_('Error')
2177         Interaction.command(title, cmd, status, out, err)
2178
2179         return status == 0
2180
2181
2182 class SetDefaultRepo(ContextCommand):
2183     """Set the default repository"""
2184
2185     def __init__(self, context, repo):
2186         super(SetDefaultRepo, self).__init__(context)
2187         self.repo = repo
2188
2189     def do(self):
2190         self.cfg.set_user('cola.defaultrepo', self.repo)
2191
2192
2193 class SetDiffText(EditModel):
2194     """Set the diff text"""
2195
2196     UNDOABLE = True
2197
2198     def __init__(self, context, text):
2199         super(SetDiffText, self).__init__(context)
2200         self.new_diff_text = text
2201         self.new_diff_type = main.Types.TEXT
2202         self.new_file_type = main.Types.TEXT
2203
2204
2205 class SetUpstreamBranch(ContextCommand):
2206     """Set the upstream branch"""
2207
2208     def __init__(self, context, branch, remote, remote_branch):
2209         super(SetUpstreamBranch, self).__init__(context)
2210         self.branch = branch
2211         self.remote = remote
2212         self.remote_branch = remote_branch
2213
2214     def do(self):
2215         cfg = self.cfg
2216         remote = self.remote
2217         branch = self.branch
2218         remote_branch = self.remote_branch
2219         cfg.set_repo('branch.%s.remote' % branch, remote)
2220         cfg.set_repo('branch.%s.merge' % branch, 'refs/heads/' + remote_branch)
2221
2222
2223 def format_hex(data):
2224     """Translate binary data into a hex dump"""
2225     hexdigits = '0123456789ABCDEF'
2226     result = ''
2227     offset = 0
2228     byte_offset_to_int = compat.byte_offset_to_int_converter()
2229     while offset < len(data):
2230         result += '%04u |' % offset
2231         textpart = ''
2232         for i in range(0, 16):
2233             if i > 0 and i % 4 == 0:
2234                 result += ' '
2235             if offset < len(data):
2236                 v = byte_offset_to_int(data[offset])
2237                 result += ' ' + hexdigits[v >> 4] + hexdigits[v & 0xF]
2238                 textpart += chr(v) if 32 <= v < 127 else '.'
2239                 offset += 1
2240             else:
2241                 result += '   '
2242                 textpart += ' '
2243         result += ' | ' + textpart + ' |\n'
2244
2245     return result
2246
2247
2248 class ShowUntracked(EditModel):
2249     """Show an untracked file."""
2250
2251     def __init__(self, context, filename):
2252         super(ShowUntracked, self).__init__(context)
2253         self.new_filename = filename
2254         self.new_mode = self.model.mode_untracked
2255         self.new_diff_text = self.read(filename)
2256         self.new_diff_type = main.Types.TEXT
2257         self.new_file_type = main.Types.TEXT
2258
2259     def read(self, filename):
2260         """Read file contents"""
2261         cfg = self.cfg
2262         size = cfg.get('cola.readsize', 2048)
2263         try:
2264             result = core.read(filename, size=size, encoding='bytes')
2265         except (IOError, OSError):
2266             result = ''
2267
2268         truncated = len(result) == size
2269
2270         encoding = cfg.file_encoding(filename) or core.ENCODING
2271         try:
2272             text_result = core.decode_maybe(result, encoding)
2273         except UnicodeError:
2274             text_result = format_hex(result)
2275
2276         if truncated:
2277             text_result += '...'
2278         return text_result
2279
2280
2281 class SignOff(ContextCommand):
2282     """Append a signoff to the commit message"""
2283
2284     UNDOABLE = True
2285
2286     @staticmethod
2287     def name():
2288         return N_('Sign Off')
2289
2290     def __init__(self, context):
2291         super(SignOff, self).__init__(context)
2292         self.old_commitmsg = self.model.commitmsg
2293
2294     def do(self):
2295         """Add a signoff to the commit message"""
2296         signoff = self.signoff()
2297         if signoff in self.model.commitmsg:
2298             return
2299         msg = self.model.commitmsg.rstrip()
2300         self.model.set_commitmsg(msg + '\n' + signoff)
2301
2302     def undo(self):
2303         """Restore the commit message"""
2304         self.model.set_commitmsg(self.old_commitmsg)
2305
2306     def signoff(self):
2307         """Generate the signoff string"""
2308         try:
2309             import pwd  # pylint: disable=all
2310
2311             user = pwd.getpwuid(os.getuid()).pw_name
2312         except ImportError:
2313             user = os.getenv('USER', N_('unknown'))
2314
2315         cfg = self.cfg
2316         name = cfg.get('user.name', user)
2317         email = cfg.get('user.email', '%s@%s' % (user, core.node()))
2318         return '\nSigned-off-by: %s <%s>' % (name, email)
2319
2320
2321 def check_conflicts(context, unmerged):
2322     """Check paths for conflicts
2323
2324     Conflicting files can be filtered out one-by-one.
2325
2326     """
2327     if prefs.check_conflicts(context):
2328         unmerged = [path for path in unmerged if is_conflict_free(path)]
2329     return unmerged
2330
2331
2332 def is_conflict_free(path):
2333     """Return True if `path` contains no conflict markers"""
2334     rgx = re.compile(r'^(<<<<<<<|\|\|\|\|\|\|\||>>>>>>>) ')
2335     try:
2336         with core.xopen(path, 'r') as f:
2337             for line in f:
2338                 line = core.decode(line, errors='ignore')
2339                 if rgx.match(line):
2340                     return should_stage_conflicts(path)
2341     except IOError:
2342         # We can't read this file ~ we may be staging a removal
2343         pass
2344     return True
2345
2346
2347 def should_stage_conflicts(path):
2348     """Inform the user that a file contains merge conflicts
2349
2350     Return `True` if we should stage the path nonetheless.
2351
2352     """
2353     title = msg = N_('Stage conflicts?')
2354     info = (
2355         N_(
2356             '%s appears to contain merge conflicts.\n\n'
2357             'You should probably skip this file.\n'
2358             'Stage it anyways?'
2359         )
2360         % path
2361     )
2362     ok_text = N_('Stage conflicts')
2363     cancel_text = N_('Skip')
2364     return Interaction.confirm(
2365         title, msg, info, ok_text, default=False, cancel_text=cancel_text
2366     )
2367
2368
2369 class Stage(ContextCommand):
2370     """Stage a set of paths."""
2371
2372     @staticmethod
2373     def name():
2374         return N_('Stage')
2375
2376     def __init__(self, context, paths):
2377         super(Stage, self).__init__(context)
2378         self.paths = paths
2379
2380     def do(self):
2381         msg = N_('Staging: %s') % (', '.join(self.paths))
2382         Interaction.log(msg)
2383         return self.stage_paths()
2384
2385     def stage_paths(self):
2386         """Stages add/removals to git."""
2387         context = self.context
2388         paths = self.paths
2389         if not paths:
2390             if self.model.cfg.get('cola.safemode', False):
2391                 return (0, '', '')
2392             return self.stage_all()
2393
2394         add = []
2395         remove = []
2396
2397         for path in set(paths):
2398             if core.exists(path) or core.islink(path):
2399                 if path.endswith('/'):
2400                     path = path.rstrip('/')
2401                 add.append(path)
2402             else:
2403                 remove.append(path)
2404
2405         self.model.emit_about_to_update()
2406
2407         # `git add -u` doesn't work on untracked files
2408         if add:
2409             status, out, err = gitcmds.add(context, add)
2410             Interaction.command(N_('Error'), 'git add', status, out, err)
2411
2412         # If a path doesn't exist then that means it should be removed
2413         # from the index.   We use `git add -u` for that.
2414         if remove:
2415             status, out, err = gitcmds.add(context, remove, u=True)
2416             Interaction.command(N_('Error'), 'git add -u', status, out, err)
2417
2418         self.model.update_files(emit=True)
2419         return status, out, err
2420
2421     def stage_all(self):
2422         """Stage all files"""
2423         status, out, err = self.git.add(v=True, u=True)
2424         Interaction.command(N_('Error'), 'git add -u', status, out, err)
2425         self.model.update_file_status()
2426         return (status, out, err)
2427
2428
2429 class StageCarefully(Stage):
2430     """Only stage when the path list is non-empty
2431
2432     We use "git add -u -- <pathspec>" to stage, and it stages everything by
2433     default when no pathspec is specified, so this class ensures that paths
2434     are specified before calling git.
2435
2436     When no paths are specified, the command does nothing.
2437
2438     """
2439
2440     def __init__(self, context):
2441         super(StageCarefully, self).__init__(context, None)
2442         self.init_paths()
2443
2444     # pylint: disable=no-self-use
2445     def init_paths(self):
2446         """Initialize path data"""
2447         return
2448
2449     def ok_to_run(self):
2450         """Prevent catch-all "git add -u" from adding unmerged files"""
2451         return self.paths or not self.model.unmerged
2452
2453     def do(self):
2454         """Stage files when ok_to_run() return True"""
2455         if self.ok_to_run():
2456             return super(StageCarefully, self).do()
2457         return (0, '', '')
2458
2459
2460 class StageModified(StageCarefully):
2461     """Stage all modified files."""
2462
2463     @staticmethod
2464     def name():
2465         return N_('Stage Modified')
2466
2467     def init_paths(self):
2468         self.paths = self.model.modified
2469
2470
2471 class StageUnmerged(StageCarefully):
2472     """Stage unmerged files."""
2473
2474     @staticmethod
2475     def name():
2476         return N_('Stage Unmerged')
2477
2478     def init_paths(self):
2479         self.paths = check_conflicts(self.context, self.model.unmerged)
2480
2481
2482 class StageUntracked(StageCarefully):
2483     """Stage all untracked files."""
2484
2485     @staticmethod
2486     def name():
2487         return N_('Stage Untracked')
2488
2489     def init_paths(self):
2490         self.paths = self.model.untracked
2491
2492
2493 class StageModifiedAndUntracked(StageCarefully):
2494     """Stage all untracked files."""
2495
2496     @staticmethod
2497     def name():
2498         return N_('Stage Modified and Untracked')
2499
2500     def init_paths(self):
2501         self.paths = self.model.modified + self.model.untracked
2502
2503
2504 class StageOrUnstageAll(ContextCommand):
2505     """If the selection is staged, unstage it, otherwise stage"""
2506     @staticmethod
2507     def name():
2508         return N_('Stage / Unstage All')
2509
2510     def do(self):
2511         if self.model.staged:
2512             do(Unstage, self.context, self.model.staged)
2513         else:
2514             unstaged = self.model.modified + self.model.untracked
2515             do(Stage, self.context, unstaged)
2516
2517
2518 class StageOrUnstage(ContextCommand):
2519     """If the selection is staged, unstage it, otherwise stage"""
2520
2521     @staticmethod
2522     def name():
2523         return N_('Stage / Unstage')
2524
2525     def do(self):
2526         s = self.selection.selection()
2527         if s.staged:
2528             do(Unstage, self.context, s.staged)
2529
2530         unstaged = []
2531         unmerged = check_conflicts(self.context, s.unmerged)
2532         if unmerged:
2533             unstaged.extend(unmerged)
2534         if s.modified:
2535             unstaged.extend(s.modified)
2536         if s.untracked:
2537             unstaged.extend(s.untracked)
2538         if unstaged:
2539             do(Stage, self.context, unstaged)
2540
2541
2542 class Tag(ContextCommand):
2543     """Create a tag object."""
2544
2545     def __init__(self, context, name, revision, sign=False, message=''):
2546         super(Tag, self).__init__(context)
2547         self._name = name
2548         self._message = message
2549         self._revision = revision
2550         self._sign = sign
2551
2552     def do(self):
2553         result = False
2554         git = self.git
2555         revision = self._revision
2556         tag_name = self._name
2557         tag_message = self._message
2558
2559         if not revision:
2560             Interaction.critical(
2561                 N_('Missing Revision'), N_('Please specify a revision to tag.')
2562             )
2563             return result
2564
2565         if not tag_name:
2566             Interaction.critical(
2567                 N_('Missing Name'), N_('Please specify a name for the new tag.')
2568             )
2569             return result
2570
2571         title = N_('Missing Tag Message')
2572         message = N_('Tag-signing was requested but the tag message is empty.')
2573         info = N_(
2574             'An unsigned, lightweight tag will be created instead.\n'
2575             'Create an unsigned tag?'
2576         )
2577         ok_text = N_('Create Unsigned Tag')
2578         sign = self._sign
2579         if sign and not tag_message:
2580             # We require a message in order to sign the tag, so if they
2581             # choose to create an unsigned tag we have to clear the sign flag.
2582             if not Interaction.confirm(
2583                 title, message, info, ok_text, default=False, icon=icons.save()
2584             ):
2585                 return result
2586             sign = False
2587
2588         opts = {}
2589         tmp_file = None
2590         try:
2591             if tag_message:
2592                 tmp_file = utils.tmp_filename('tag-message')
2593                 opts['file'] = tmp_file
2594                 core.write(tmp_file, tag_message)
2595
2596             if sign:
2597                 opts['sign'] = True
2598             if tag_message:
2599                 opts['annotate'] = True
2600             status, out, err = git.tag(tag_name, revision, **opts)
2601         finally:
2602             if tmp_file:
2603                 core.unlink(tmp_file)
2604
2605         title = N_('Error: could not create tag "%s"') % tag_name
2606         Interaction.command(title, 'git tag', status, out, err)
2607
2608         if status == 0:
2609             result = True
2610             self.model.update_status()
2611             Interaction.information(
2612                 N_('Tag Created'),
2613                 N_('Created a new tag named "%s"') % tag_name,
2614                 details=tag_message or None,
2615             )
2616
2617         return result
2618
2619
2620 class Unstage(ContextCommand):
2621     """Unstage a set of paths."""
2622
2623     @staticmethod
2624     def name():
2625         return N_('Unstage')
2626
2627     def __init__(self, context, paths):
2628         super(Unstage, self).__init__(context)
2629         self.paths = paths
2630
2631     def do(self):
2632         """Unstage paths"""
2633         context = self.context
2634         head = self.model.head
2635         paths = self.paths
2636
2637         msg = N_('Unstaging: %s') % (', '.join(paths))
2638         Interaction.log(msg)
2639         if not paths:
2640             return unstage_all(context)
2641         status, out, err = gitcmds.unstage_paths(context, paths, head=head)
2642         Interaction.command(N_('Error'), 'git reset', status, out, err)
2643         self.model.update_file_status()
2644         return (status, out, err)
2645
2646
2647 class UnstageAll(ContextCommand):
2648     """Unstage all files; resets the index."""
2649
2650     def do(self):
2651         return unstage_all(self.context)
2652
2653
2654 def unstage_all(context):
2655     """Unstage all files, even while amending"""
2656     model = context.model
2657     git = context.git
2658     head = model.head
2659     status, out, err = git.reset(head, '--', '.')
2660     Interaction.command(N_('Error'), 'git reset', status, out, err)
2661     model.update_file_status()
2662     return (status, out, err)
2663
2664
2665 class StageSelected(ContextCommand):
2666     """Stage selected files, or all files if no selection exists."""
2667
2668     def do(self):
2669         context = self.context
2670         paths = self.selection.unstaged
2671         if paths:
2672             do(Stage, context, paths)
2673         elif self.cfg.get('cola.safemode', False):
2674             do(StageModified, context)
2675
2676
2677 class UnstageSelected(Unstage):
2678     """Unstage selected files."""
2679
2680     def __init__(self, context):
2681         staged = self.selection.staged
2682         super(UnstageSelected, self).__init__(context, staged)
2683
2684
2685 class Untrack(ContextCommand):
2686     """Unstage a set of paths."""
2687
2688     def __init__(self, context, paths):
2689         super(Untrack, self).__init__(context)
2690         self.paths = paths
2691
2692     def do(self):
2693         msg = N_('Untracking: %s') % (', '.join(self.paths))
2694         Interaction.log(msg)
2695         status, out, err = self.model.untrack_paths(self.paths)
2696         Interaction.log_status(status, out, err)
2697
2698
2699 class UntrackedSummary(EditModel):
2700     """List possible .gitignore rules as the diff text."""
2701
2702     def __init__(self, context):
2703         super(UntrackedSummary, self).__init__(context)
2704         untracked = self.model.untracked
2705         suffix = 's' if untracked else ''
2706         io = StringIO()
2707         io.write('# %s untracked file%s\n' % (len(untracked), suffix))
2708         if untracked:
2709             io.write('# possible .gitignore rule%s:\n' % suffix)
2710             for u in untracked:
2711                 io.write('/' + u + '\n')
2712         self.new_diff_text = io.getvalue()
2713         self.new_diff_type = main.Types.TEXT
2714         self.new_file_type = main.Types.TEXT
2715         self.new_mode = self.model.mode_untracked
2716
2717
2718 class VisualizeAll(ContextCommand):
2719     """Visualize all branches."""
2720
2721     def do(self):
2722         context = self.context
2723         browser = utils.shell_split(prefs.history_browser(context))
2724         launch_history_browser(browser + ['--all'])
2725
2726
2727 class VisualizeCurrent(ContextCommand):
2728     """Visualize all branches."""
2729
2730     def do(self):
2731         context = self.context
2732         browser = utils.shell_split(prefs.history_browser(context))
2733         launch_history_browser(browser + [self.model.currentbranch] + ['--'])
2734
2735
2736 class VisualizePaths(ContextCommand):
2737     """Path-limited visualization."""
2738
2739     def __init__(self, context, paths):
2740         super(VisualizePaths, self).__init__(context)
2741         context = self.context
2742         browser = utils.shell_split(prefs.history_browser(context))
2743         if paths:
2744             self.argv = browser + ['--'] + list(paths)
2745         else:
2746             self.argv = browser
2747
2748     def do(self):
2749         launch_history_browser(self.argv)
2750
2751
2752 class VisualizeRevision(ContextCommand):
2753     """Visualize a specific revision."""
2754
2755     def __init__(self, context, revision, paths=None):
2756         super(VisualizeRevision, self).__init__(context)
2757         self.revision = revision
2758         self.paths = paths
2759
2760     def do(self):
2761         context = self.context
2762         argv = utils.shell_split(prefs.history_browser(context))
2763         if self.revision:
2764             argv.append(self.revision)
2765         if self.paths:
2766             argv.append('--')
2767             argv.extend(self.paths)
2768         launch_history_browser(argv)
2769
2770
2771 class SubmoduleAdd(ConfirmAction):
2772     """Add specified submodules"""
2773
2774     def __init__(self, context, url, path, branch, depth, reference):
2775         super(SubmoduleAdd, self).__init__(context)
2776         self.url = url
2777         self.path = path
2778         self.branch = branch
2779         self.depth = depth
2780         self.reference = reference
2781
2782     def confirm(self):
2783         title = N_('Add Submodule...')
2784         question = N_('Add this submodule?')
2785         info = N_('The submodule will be added using\n' '"%s"' % self.command())
2786         ok_txt = N_('Add Submodule')
2787         return Interaction.confirm(title, question, info, ok_txt, icon=icons.ok())
2788
2789     def action(self):
2790         context = self.context
2791         args = self.get_args()
2792         return context.git.submodule('add', *args)
2793
2794     def success(self):
2795         self.model.update_file_status()
2796         self.model.update_submodules_list()
2797
2798     def error_message(self):
2799         return N_('Error updating submodule %s' % self.path)
2800
2801     def command(self):
2802         cmd = ['git', 'submodule', 'add']
2803         cmd.extend(self.get_args())
2804         return core.list2cmdline(cmd)
2805
2806     def get_args(self):
2807         args = []
2808         if self.branch:
2809             args.extend(['--branch', self.branch])
2810         if self.reference:
2811             args.extend(['--reference', self.reference])
2812         if self.depth:
2813             args.extend(['--depth', '%d' % self.depth])
2814         args.extend(['--', self.url])
2815         if self.path:
2816             args.append(self.path)
2817         return args
2818
2819
2820 class SubmoduleUpdate(ConfirmAction):
2821     """Update specified submodule"""
2822
2823     def __init__(self, context, path):
2824         super(SubmoduleUpdate, self).__init__(context)
2825         self.path = path
2826
2827     def confirm(self):
2828         title = N_('Update Submodule...')
2829         question = N_('Update this submodule?')
2830         info = N_('The submodule will be updated using\n' '"%s"' % self.command())
2831         ok_txt = N_('Update Submodule')
2832         return Interaction.confirm(
2833             title, question, info, ok_txt, default=False, icon=icons.pull()
2834         )
2835
2836     def action(self):
2837         context = self.context
2838         args = self.get_args()
2839         return context.git.submodule(*args)
2840
2841     def success(self):
2842         self.model.update_file_status()
2843
2844     def error_message(self):
2845         return N_('Error updating submodule %s' % self.path)
2846
2847     def command(self):
2848         cmd = ['git', 'submodule']
2849         cmd.extend(self.get_args())
2850         return core.list2cmdline(cmd)
2851
2852     def get_args(self):
2853         cmd = ['update']
2854         if version.check_git(self.context, 'submodule-update-recursive'):
2855             cmd.append('--recursive')
2856         cmd.extend(['--', self.path])
2857         return cmd
2858
2859
2860 class SubmodulesUpdate(ConfirmAction):
2861     """Update all submodules"""
2862
2863     def confirm(self):
2864         title = N_('Update submodules...')
2865         question = N_('Update all submodules?')
2866         info = N_('All submodules will be updated using\n' '"%s"' % self.command())
2867         ok_txt = N_('Update Submodules')
2868         return Interaction.confirm(
2869             title, question, info, ok_txt, default=False, icon=icons.pull()
2870         )
2871
2872     def action(self):
2873         context = self.context
2874         args = self.get_args()
2875         return context.git.submodule(*args)
2876
2877     def success(self):
2878         self.model.update_file_status()
2879
2880     def error_message(self):
2881         return N_('Error updating submodules')
2882
2883     def command(self):
2884         cmd = ['git', 'submodule']
2885         cmd.extend(self.get_args())
2886         return core.list2cmdline(cmd)
2887
2888     def get_args(self):
2889         cmd = ['update']
2890         if version.check_git(self.context, 'submodule-update-recursive'):
2891             cmd.append('--recursive')
2892         return cmd
2893
2894
2895 def launch_history_browser(argv):
2896     """Launch the configured history browser"""
2897     try:
2898         core.fork(argv)
2899     except OSError as e:
2900         _, details = utils.format_exception(e)
2901         title = N_('Error Launching History Browser')
2902         msg = N_('Cannot exec "%s": please configure a history browser') % ' '.join(
2903             argv
2904         )
2905         Interaction.critical(title, message=msg, details=details)
2906
2907
2908 def run(cls, *args, **opts):
2909     """
2910     Returns a callback that runs a command
2911
2912     If the caller of run() provides args or opts then those are
2913     used instead of the ones provided by the invoker of the callback.
2914
2915     """
2916
2917     def runner(*local_args, **local_opts):
2918         """Closure return by run() which runs the command"""
2919         if args or opts:
2920             do(cls, *args, **opts)
2921         else:
2922             do(cls, *local_args, **local_opts)
2923
2924     return runner
2925
2926
2927 def do(cls, *args, **opts):
2928     """Run a command in-place"""
2929     try:
2930         cmd = cls(*args, **opts)
2931         return cmd.do()
2932     except Exception as e:  # pylint: disable=broad-except
2933         msg, details = utils.format_exception(e)
2934         if hasattr(cls, '__name__'):
2935             msg = '%s exception:\n%s' % (cls.__name__, msg)
2936         Interaction.critical(N_('Error'), message=msg, details=details)
2937         return None
2938
2939
2940 def difftool_run(context):
2941     """Start a default difftool session"""
2942     selection = context.selection
2943     files = selection.group()
2944     if not files:
2945         return
2946     s = selection.selection()
2947     head = context.model.head
2948     difftool_launch_with_head(context, files, bool(s.staged), head)
2949
2950
2951 def difftool_launch_with_head(context, filenames, staged, head):
2952     """Launch difftool against the provided head"""
2953     if head == 'HEAD':
2954         left = None
2955     else:
2956         left = head
2957     difftool_launch(context, left=left, staged=staged, paths=filenames)
2958
2959
2960 def difftool_launch(
2961     context,
2962     left=None,
2963     right=None,
2964     paths=None,
2965     staged=False,
2966     dir_diff=False,
2967     left_take_magic=False,
2968     left_take_parent=False,
2969 ):
2970     """Launches 'git difftool' with given parameters
2971
2972     :param left: first argument to difftool
2973     :param right: second argument to difftool_args
2974     :param paths: paths to diff
2975     :param staged: activate `git difftool --staged`
2976     :param dir_diff: activate `git difftool --dir-diff`
2977     :param left_take_magic: whether to append the magic ^! diff expression
2978     :param left_take_parent: whether to append the first-parent ~ for diffing
2979
2980     """
2981
2982     difftool_args = ['git', 'difftool', '--no-prompt']
2983     if staged:
2984         difftool_args.append('--cached')
2985     if dir_diff:
2986         difftool_args.append('--dir-diff')
2987
2988     if left:
2989         if left_take_parent or left_take_magic:
2990             suffix = '^!' if left_take_magic else '~'
2991             # Check root commit (no parents and thus cannot execute '~')
2992             git = context.git
2993             status, out, err = git.rev_list(left, parents=True, n=1)
2994             Interaction.log_status(status, out, err)
2995             if status:
2996                 raise OSError('git rev-list command failed')
2997
2998             if len(out.split()) >= 2:
2999                 # Commit has a parent, so we can take its child as requested
3000                 left += suffix
3001             else:
3002                 # No parent, assume it's the root commit, so we have to diff
3003                 # against the empty tree.
3004                 left = EMPTY_TREE_OID
3005                 if not right and left_take_magic:
3006                     right = left
3007         difftool_args.append(left)
3008
3009     if right:
3010         difftool_args.append(right)
3011
3012     if paths:
3013         difftool_args.append('--')
3014         difftool_args.extend(paths)
3015
3016     runtask = context.runtask
3017     if runtask:
3018         Interaction.async_command(N_('Difftool'), difftool_args, runtask)
3019     else:
3020         core.fork(difftool_args)