org.eclipse.egit.ui/src/org/eclipse/egit/ui/internal/actions/RepositoryActionHandler.java

   1 /*******************************************************************************
   2  * Copyright (C) 2007, Dave Watson <dwatson@mimvista.com>
   3  * Copyright (C) 2008, Robin Rosenberg <robin.rosenberg@dewire.com>
   4  * Copyright (C) 2006, Shawn O. Pearce <spearce@spearce.org>
   5  * Copyright (C) 2010, Mathias Kinzler <mathias.kinzler@sap.com>
   6  * Copyright (C) 2011, Dariusz Luksza <dariusz@luksza.org>
   7  * Copyright (C) 2012, 2013 Robin Stocker <robin@nibor.org>
   8  * Copyright (C) 2012, 2013 François Rey <eclipse.org_@_francois_._rey_._name>
   9  * Copyright (C) 2013 Laurent Goubet <laurent.goubet@obeo.fr>
  10  * Copyright (C) 2015, IBM Corporation (Dani Megert <daniel_megert@ch.ibm.com>)
  11  * Copyright (C) 2016, Stefan Dirix <sdirix@eclipsesource.com>
  12  *
  13  * All rights reserved. This program and the accompanying materials
  14  * are made available under the terms of the Eclipse Public License 2.0
  15  * which accompanies this distribution, and is available at
  16  * https://www.eclipse.org/legal/epl-2.0/
  17  *
  18  * SPDX-License-Identifier: EPL-2.0
  19  *******************************************************************************/
  20 package org.eclipse.egit.ui.internal.actions;
  21
  22 import java.io.IOException;
  23 import java.util.ArrayList;
  24 import java.util.Arrays;
  25 import java.util.Collection;
  26 import java.util.LinkedHashSet;
  27 import java.util.List;
  28 import java.util.Set;
  29
  30 import org.eclipse.core.commands.AbstractHandler;
  31 import org.eclipse.core.commands.ExecutionEvent;
  32 import org.eclipse.core.commands.ExecutionException;
  33 import org.eclipse.core.expressions.IEvaluationContext;
  34 import org.eclipse.core.resources.IProject;
  35 import org.eclipse.core.resources.IResource;
  36 import org.eclipse.core.runtime.IPath;
  37 import org.eclipse.egit.core.internal.CompareCoreUtils;
  38 import org.eclipse.egit.core.project.RepositoryMapping;
  39 import org.eclipse.egit.ui.internal.selection.SelectionUtils;
  40 import org.eclipse.jface.viewers.ISelection;
  41 import org.eclipse.jface.viewers.IStructuredSelection;
  42 import org.eclipse.jface.viewers.StructuredSelection;
  43 import org.eclipse.jgit.diff.DiffConfig;
  44 import org.eclipse.jgit.diff.DiffEntry;
  45 import org.eclipse.jgit.lib.Constants;
  46 import org.eclipse.jgit.lib.ObjectReader;
  47 import org.eclipse.jgit.lib.Ref;
  48 import org.eclipse.jgit.lib.Repository;
  49 import org.eclipse.jgit.revwalk.FollowFilter;
  50 import org.eclipse.jgit.revwalk.RevCommit;
  51 import org.eclipse.jgit.revwalk.RevSort;
  52 import org.eclipse.jgit.revwalk.RevWalk;
  53 import org.eclipse.jgit.treewalk.filter.OrTreeFilter;
  54 import org.eclipse.jgit.treewalk.filter.TreeFilter;
  55 import org.eclipse.swt.widgets.Shell;
  56 import org.eclipse.ui.IWorkbenchPage;
  57 import org.eclipse.ui.IWorkbenchPart;
  58 import org.eclipse.ui.IWorkbenchWindowActionDelegate;
  59 import org.eclipse.ui.handlers.HandlerUtil;
  60
  61 /**
  62  * A helper class for Team Actions on Git controlled projects
  63  */
  64 abstract class RepositoryActionHandler extends AbstractHandler {
  65
  66         private IEvaluationContext evaluationContext;
  67
  68         IStructuredSelection mySelection;
  69
  70         /**
  71          * Set the selection when used by {@link RepositoryAction} as
  72          * {@link IWorkbenchWindowActionDelegate}
  73          *
  74          * @param selection
  75          *            the new selection
  76          */
  77         public void setSelection(ISelection selection) {
  78                 mySelection = SelectionUtils.getStructuredSelection(selection);
  79         }
  80
  81
  82         /**
  83          * Retrieve the list of projects that contains the selected resources. All
  84          * resources must actually map to a project shared with egit, otherwise an
  85          * empty array is returned. In case of a linked resource, the project
  86          * returned is the one that contains the link target and is shared with
  87          * egit, if any, otherwise an empty array is also returned.
  88          *
  89          * @param event
  90          * @return the projects hosting the selected resources
  91          * @throws ExecutionException
  92          */
  93         protected IProject[] getProjectsForSelectedResources(ExecutionEvent event)
  94                         throws ExecutionException {
  95                 IStructuredSelection selection = getSelection(event);
  96                 return SelectionUtils.getSelectedProjects(selection);
  97         }
  98
  99         /**
 100          * Retrieve the list of projects that contains the selected resources. All
 101          * resources must actually map to a project shared with egit, otherwise an
 102          * empty array is returned. In case of a linked resource, the project
 103          * returned is the one that contains the link target and is shared with
 104          * egit, if any, otherwise an empty array is also returned.
 105          *
 106          * @return the projects hosting the selected resources
 107          */
 108         protected IProject[] getProjectsForSelectedResources() {
 109                 IStructuredSelection selection = getSelection();
 110                 return SelectionUtils.getSelectedProjects(selection);
 111         }
 112
 113         /**
 114          * @param projects
 115          *            a list of projects
 116          * @return the repositories that projects map to if all projects are mapped
 117          */
 118         protected Repository[] getRepositoriesFor(final IProject[] projects) {
 119                 Set<Repository> ret = new LinkedHashSet<>();
 120                 for (IProject project : projects) {
 121                         RepositoryMapping repositoryMapping = RepositoryMapping
 122                                         .getMapping(project);
 123                         if (repositoryMapping == null)
 124                                 return new Repository[0];
 125                         ret.add(repositoryMapping.getRepository());
 126                 }
 127                 return ret.toArray(new Repository[0]);
 128         }
 129
 130         /**
 131          * Determines whether the selection contains only resources that are in some
 132          * git repository.
 133          *
 134          * @return {@code true} if all resources in the selection belong to a git
 135          *         repository known to EGit.
 136          */
 137         protected boolean haveSelectedResourcesWithRepository() {
 138                 IStructuredSelection selection = getSelection();
 139                 if (selection != null) {
 140                         IResource[] resources = SelectionUtils
 141                                         .getSelectedResources(selection);
 142                         if (resources.length > 0) {
 143                                 for (IResource resource : resources) {
 144                                         if (resource == null
 145                                                         || RepositoryMapping.getMapping(resource) == null) {
 146                                                 return false;
 147                                         }
 148                                 }
 149                                 return true;
 150                         }
 151                 }
 152                 return false;
 153         }
 154
 155         /**
 156          * Figure out which repository to use. All selected resources must map to
 157          * the same Git repository.
 158          *
 159          * @param warn
 160          *            Put up a message dialog to warn why a resource was not
 161          *            selected
 162          * @param event
 163          * @return repository for current project, or null
 164          * @throws ExecutionException
 165          */
 166         protected Repository getRepository(boolean warn, ExecutionEvent event)
 167                         throws ExecutionException {
 168                 IStructuredSelection selection = getSelection(event);
 169                 if (warn) {
 170                         Shell shell = getShell(event);
 171                         return SelectionUtils.getRepositoryOrWarn(selection, shell);
 172                 } else {
 173                         return SelectionUtils.getRepository(selection);
 174                 }
 175         }
 176
 177         /**
 178          * Figure out which repository to use. All selected resources must map to
 179          * the same Git repository.
 180          *
 181          * @return repository for current project, or null
 182          */
 183         protected Repository getRepository() {
 184                 IStructuredSelection selection = getSelection();
 185                 return SelectionUtils.getRepository(selection);
 186         }
 187
 188         /**
 189          * Figure out which repositories to use. All selected resources must map to
 190          * a Git repository.
 191          *
 192          * @param event
 193          *
 194          * @return repositories for selection, or an empty array
 195          * @throws ExecutionException
 196          */
 197         protected Repository[] getRepositories(ExecutionEvent event)
 198                         throws ExecutionException {
 199                 IStructuredSelection selection = getSelection(event);
 200                 return SelectionUtils.getRepositories(selection);
 201         }
 202
 203         /**
 204          * Get the currently selected repositories. All selected projects must map
 205          * to a repository.
 206          *
 207          * @return repositories for selection, or an empty array
 208          */
 209         public Repository[] getRepositories() {
 210                 IStructuredSelection selection = getSelection();
 211                 return SelectionUtils.getRepositories(selection);
 212         }
 213
 214         /**
 215          * @param event
 216          *            the execution event, must not be null
 217          * @return the current selection
 218          * @throws ExecutionException
 219          *             if the selection can't be determined
 220          */
 221         protected static IStructuredSelection getSelection(ExecutionEvent event)
 222                         throws ExecutionException {
 223                 if (event == null)
 224                         throw new IllegalArgumentException("event must not be NULL"); //$NON-NLS-1$
 225                 Object context = event.getApplicationContext();
 226                 if (context instanceof IEvaluationContext)
 227                         return SelectionUtils.getSelection((IEvaluationContext) context);
 228                 return StructuredSelection.EMPTY;
 229         }
 230
 231         /**
 232          * @return the current selection
 233          */
 234         protected IStructuredSelection getSelection() {
 235                 // if the selection was set explicitly, use it
 236                 if (mySelection != null)
 237                         return mySelection;
 238                 return SelectionUtils.getSelection(evaluationContext);
 239         }
 240
 241         @Override
 242         public void setEnabled(Object evaluationContext) {
 243                 this.evaluationContext = (IEvaluationContext) evaluationContext;
 244         }
 245
 246         /**
 247          * @param event
 248          * @return the resources in the selection
 249          * @throws ExecutionException
 250          */
 251         protected IResource[] getSelectedResources(ExecutionEvent event)
 252                         throws ExecutionException {
 253                 IStructuredSelection selection = getSelection(event);
 254                 return SelectionUtils.getSelectedResources(selection);
 255         }
 256
 257         protected IPath[] getSelectedLocations(ExecutionEvent event)
 258                         throws ExecutionException {
 259                 IStructuredSelection selection = getSelection(event);
 260                 return SelectionUtils.getSelectedLocations(selection);
 261         }
 262
 263         /**
 264          * @return the resources in the selection
 265          */
 266         protected IResource[] getSelectedResources() {
 267                 IStructuredSelection selection = getSelection();
 268                 return SelectionUtils.getSelectedResources(selection);
 269         }
 270
 271         /**
 272          * @return the locations in the selection
 273          */
 274         protected IPath[] getSelectedLocations() {
 275                 IStructuredSelection selection = getSelection();
 276                 return SelectionUtils.getSelectedLocations(selection);
 277         }
 278
 279         /**
 280          * @return true if all selected items map to the same repository, false otherwise.
 281          */
 282         protected boolean selectionMapsToSingleRepository() {
 283                 return getRepository() != null;
 284         }
 285
 286         /**
 287          * @param event
 288          * @return the shell
 289          * @throws ExecutionException
 290          */
 291         protected Shell getShell(ExecutionEvent event) throws ExecutionException {
 292                 return HandlerUtil.getActiveShellChecked(event);
 293         }
 294
 295         /**
 296          * @param event
 297          * @return the page
 298          * @throws ExecutionException
 299          */
 300         protected IWorkbenchPage getPartPage(ExecutionEvent event)
 301                         throws ExecutionException {
 302                 return getPart(event).getSite().getPage();
 303         }
 304
 305         /**
 306          * @param event
 307          * @return the page
 308          * @throws ExecutionException
 309          */
 310         protected IWorkbenchPart getPart(ExecutionEvent event)
 311                         throws ExecutionException {
 312                 return HandlerUtil.getActivePartChecked(event);
 313         }
 314
 315
 316         /**
 317          *
 318          * @param repository
 319          *            the repository to check
 320          * @return {@code true} when {@link Constants#HEAD} can be resolved,
 321          *         {@code false} otherwise
 322          */
 323         protected boolean containsHead(Repository repository) {
 324                 try {
 325                         return repository != null ? repository.resolve(Constants.HEAD) != null
 326                                         : false;
 327                 } catch (Exception e) {
 328                         // do nothing
 329                 }
 330
 331                 return false;
 332         }
 333
 334         protected boolean isLocalBranchCheckedout(Repository repository) {
 335                 try {
 336                         String fullBranch = repository.getFullBranch();
 337                         return fullBranch != null
 338                                         && fullBranch.startsWith(Constants.R_HEADS);
 339                 } catch (Exception e) {
 340                         // do nothing
 341                 }
 342
 343                 return false;
 344         }
 345
 346         protected String getPreviousPath(Repository repository,
 347                         ObjectReader reader, RevCommit headCommit,
 348                         RevCommit previousCommit, String path) throws IOException {
 349                 DiffEntry diffEntry = CompareCoreUtils.getChangeDiffEntry(repository, path,
 350                                 headCommit, previousCommit, reader);
 351                 if (diffEntry != null)
 352                         return diffEntry.getOldPath();
 353                 else
 354                         return path;
 355         }
 356
 357         protected RevCommit getHeadCommit(IResource resource) throws IOException {
 358                 Repository repository = getRepository();
 359                 if (resource == null) {
 360                         return null;
 361                 }
 362                 RepositoryMapping mapping = RepositoryMapping.getMapping(resource);
 363                 if (mapping == null) {
 364                         return null;
 365                 }
 366                 String path = mapping.getRepoRelativePath(resource);
 367                 if (path == null) {
 368                         return null;
 369                 }
 370                 try (RevWalk rw = new RevWalk(repository)) {
 371                         rw.sort(RevSort.COMMIT_TIME_DESC, true);
 372                         rw.sort(RevSort.BOUNDARY, true);
 373                         if (path.length() > 0) {
 374                                 DiffConfig diffConfig = repository.getConfig().get(
 375                                                 DiffConfig.KEY);
 376                                 FollowFilter filter = FollowFilter.create(path, diffConfig);
 377                                 rw.setTreeFilter(filter);
 378                         }
 379
 380                         Ref head = repository.findRef(Constants.HEAD);
 381                         if (head == null) {
 382                                 return null;
 383                         }
 384                         RevCommit headCommit = rw.parseCommit(head.getObjectId());
 385                         rw.close();
 386                         return headCommit;
 387                 }
 388         }
 389
 390         /**
 391          * Returns the previous commit of the given resources.
 392          *
 393          * @param resources
 394          *            The {@link IResource} for which the previous commit shall be
 395          *            determined.
 396          * @return The second to last commit which touched any of the given
 397          *         resources.
 398          * @throws IOException
 399          *             When the commit can not be parsed.
 400          */
 401         protected List<RevCommit> findPreviousCommits(
 402                         Collection<IResource> resources) throws IOException {
 403                 List<RevCommit> result = new ArrayList<>();
 404                 Repository repository = getRepository();
 405                 RepositoryMapping mapping = RepositoryMapping.getMapping(resources
 406                                 .iterator().next()
 407                                 .getProject());
 408                 if (mapping == null) {
 409                         return result;
 410                 }
 411                 try (RevWalk rw = new RevWalk(repository)) {
 412                         rw.sort(RevSort.COMMIT_TIME_DESC, true);
 413                         rw.sort(RevSort.BOUNDARY, true);
 414
 415                         List<TreeFilter> filters = new ArrayList<>();
 416                         DiffConfig diffConfig = repository.getConfig().get(DiffConfig.KEY);
 417                         for (IResource resource : resources) {
 418                                 String path = mapping.getRepoRelativePath(resource);
 419
 420                                 if (path != null && path.length() > 0) {
 421                                         filters.add(FollowFilter.create(path, diffConfig));
 422                                 }
 423                         }
 424
 425                         if (filters.size() >= 2) {
 426                                 TreeFilter filter = OrTreeFilter.create(filters);
 427                                 rw.setTreeFilter(filter);
 428                         } else if (filters.size() == 1) {
 429                                 rw.setTreeFilter(filters.get(0));
 430                         }
 431
 432                         Ref head = repository.findRef(Constants.HEAD);
 433                         if (head == null) {
 434                                 return result;
 435                         }
 436                         RevCommit headCommit = rw.parseCommit(head.getObjectId());
 437                         rw.markStart(headCommit);
 438                         headCommit = rw.next();
 439
 440                         if (headCommit == null)
 441                                 return result;
 442                         List<RevCommit> directParents = Arrays.asList(headCommit
 443                                         .getParents());
 444
 445                         RevCommit previousCommit = rw.next();
 446                         while (previousCommit != null && result.size() < directParents.size()) {
 447                                 if (directParents.contains(previousCommit)) {
 448                                         result.add(previousCommit);
 449                                 }
 450                                 previousCommit = rw.next();
 451                         }
 452                         rw.dispose();
 453                 }
 454                 return result;
 455         }
 456
 457         // keep track of the path of an ancestor (for following renames)
 458         protected static final class PreviousCommit {
 459                 final RevCommit commit;
 460                 final String path;
 461                 PreviousCommit(final RevCommit commit, final String path) {
 462                         this.commit = commit;
 463                         this.path = path;
 464                 }
 465         }
 466
 467         /**
 468          * By default egit operates only on resources that map to a project shared
 469          * with egit. For linked resources the project that contains the link
 470          * target, if any, must be shared with egit.
 471          *
 472          * @return the projects hosting the selected resources
 473          */
 474         @Override
 475         public boolean isEnabled() {
 476                 return getProjectsForSelectedResources().length > 0;
 477         }
 478
 479         /**
 480          * Determines whether the enablement state shall always be recomputed or
 481          * only when the selection changes. This default implementation returns
 482          * {@code false}.
 483          *
 484          * @return {@code false} if the enablement state depends solely on the
 485          *         selection, {@code true} if the enablement must be recomputed even
 486          *         if the selection did not change.
 487          */
 488         protected boolean alwaysCheckEnabled() {
 489                 return false;
 490         }
 491 }