Java Code Examples for com.intellij.openapi.vcs.changes.Change#getAfterRevision()

@Override
public boolean matches(@Nonnull VcsCommitMetadata details) {
  if ((details instanceof VcsFullCommitDetails)) {
    for (Change change : ((VcsFullCommitDetails)details).getChanges()) {
      ContentRevision before = change.getBeforeRevision();
      if (before != null && matches(before.getFile().getPath())) {
        return true;
      }
      ContentRevision after = change.getAfterRevision();
      if (after != null && matches(after.getFile().getPath())) {
        return true;
      }
    }
    return false;
  }
  else {
    return false;
  }
}
 

private static void addOrReplaceChange(final List<Change> changes, final Change c) {
  final ContentRevision beforeRev = c.getBeforeRevision();
  // todo!!! further improvements needed
  if (beforeRev != null) {
    final String beforeName = beforeRev.getFile().getName();
    final String beforeAbsolutePath = beforeRev.getFile().getIOFile().getAbsolutePath();
    for (Change oldChange : changes) {
      ContentRevision rev = oldChange.getAfterRevision();
      // first compare name, which is many times faster - to remove 99% not matching
      if (rev != null && (rev.getFile().getName().equals(beforeName)) && rev.getFile().getIOFile().getAbsolutePath().equals(beforeAbsolutePath)) {
        changes.remove(oldChange);
        if (oldChange.getBeforeRevision() != null || c.getAfterRevision() != null) {
          changes.add(new Change(oldChange.getBeforeRevision(), c.getAfterRevision()));
        }
        return;
      }
    }
  }
  changes.add(c);
}
 

public void rollbackChanges(final List<Change> changes,
                            final List<VcsException> vcsExceptions,
                            @NotNull final RollbackProgressListener listener) {
    logger.info("rollbackChanges started");
    final List<FilePath> localPaths = new ArrayList<FilePath>();

    listener.determinate();
    for (final Change change : changes) {
        final ContentRevision revision = change.getType() == Change.Type.DELETED ? change.getBeforeRevision() : change.getAfterRevision();
        localPaths.add(revision.getFile());
    }

    undoPendingChanges(localPaths, vcsExceptions, listener);
    logger.info("rollbackChanges ended");
}
 

private List<OptionalClientServerConfig> getConfigsForChanges(Collection<Change> changes) {
    ProjectConfigRegistry registry = ProjectConfigRegistry.getInstance(project);
    if (registry == null) {
        return Collections.emptyList();
    }
    List<FilePath> files = new ArrayList<>(changes.size() * 2);
    for (Change change : changes) {
        ContentRevision before = change.getBeforeRevision();
        if (before != null) {
            files.add(before.getFile());
        }
        ContentRevision after = change.getAfterRevision();
        if (after != null) {
            files.add(after.getFile());
        }
    }
    // We only need the unique servers; multiples of the same server will result
    // in excessive job queries.  Instead, we'll find one of the clients associated
    // with each server.
    Map<P4ServerName, OptionalClientServerConfig> configs = new HashMap<>();
    for (FilePath file : files) {
        ClientConfigRoot config = registry.getClientFor(file);
        if (config != null && !configs.containsKey(config.getServerConfig().getServerName())) {
            configs.put(
                    config.getServerConfig().getServerName(),
                    new OptionalClientServerConfig(config.getClientConfig()));
        }
    }
    return new ArrayList<>(configs.values());
}
 

private void addChange(@Nullable String changeListName, @NotNull Change change) {
    addedChanges.put(changeListName, change);
    if (change.getBeforeRevision() != null) {
        addedChangedFiles.put(changeListName, change.getBeforeRevision().getFile());
    }
    if (change.getAfterRevision() != null) {
        addedChangedFiles.put(changeListName, change.getAfterRevision().getFile());
    }
}
 

@Nonnull
public Collection<String> getModifiedPaths() {
  Set<String> changedPaths = ContainerUtil.newHashSet();
  for (Change change : getChanges()) {
    if (change.getAfterRevision() != null) changedPaths.add(change.getAfterRevision().getFile().getPath());
    if (change.getBeforeRevision() != null) changedPaths.add(change.getBeforeRevision().getFile().getPath());
  }
  return changedPaths;
}
 

@Nonnull
public Collection<Couple<String>> getRenamedPaths() {
  Set<Couple<String>> renames = ContainerUtil.newHashSet();
  for (Change change : getChanges()) {
    if (change.getType().equals(Change.Type.MOVED)) {
      if (change.getAfterRevision() != null && change.getBeforeRevision() != null) {
        renames.add(Couple.of(change.getBeforeRevision().getFile().getPath(), change.getAfterRevision().getFile().getPath()));
      }
    }
  }
  return renames;
}
 

/**
 * @param change "Change" description.
 * @return Return true if the "Change" object is created for "Rename" operation:
 *         in this case name of files for "before" and "after" revisions must not
 *         coniside.
 */
public static boolean isRenameChange(Change change) {
  boolean isRenamed = false;
  ContentRevision before = change.getBeforeRevision();
  ContentRevision after = change.getAfterRevision();
  if (before != null && after != null) {
    String prevFile = getCanonicalLocalPath(before.getFile().getPath());
    String newFile = getCanonicalLocalPath(after.getFile().getPath());
    isRenamed = !prevFile.equals(newFile);
  }
  return isRenamed;
}
 

public void execute() {
  for (Change change : changes) {
    ProgressManager.checkCanceled();
    if (change.getAfterRevision() == null) continue;
    final VirtualFile afterFile = getFileWithRefresh(change.getAfterRevision().getFile());
    if (afterFile == null || afterFile.isDirectory() || afterFile.getFileType().isBinary()) continue;
    myPsiFile = null;

    if (afterFile.isValid()) {
      myPsiFile = ApplicationManager.getApplication().runReadAction(new Computable<PsiFile>() {
        @Override
        public PsiFile compute() {
          return myPsiManager.findFile(afterFile);
        }
      });
    }
    if (myPsiFile == null) {
      mySkipped.add(Pair.create(change.getAfterRevision().getFile(), ourInvalidFile));
      continue;
    }

    myNewTodoItems = new ArrayList<TodoItem>(Arrays.asList(
            ApplicationManager.getApplication().runReadAction(new Computable<TodoItem[]>() {
              @Override
              public TodoItem[] compute() {
                return mySearchHelper.findTodoItems(myPsiFile);
              }
            })));
    applyFilterAndRemoveDuplicates(myNewTodoItems, myTodoFilter);
    if (change.getBeforeRevision() == null) {
      // take just all todos
      if (myNewTodoItems.isEmpty()) continue;
      myAddedOrEditedTodos.addAll(myNewTodoItems);
    }
    else {
      myEditedFileProcessor.process(change, myNewTodoItems);
    }
  }
}
 

private static boolean hasValidChanges(final Change[] changes) {
  for(Change c: changes) {
    final ContentRevision contentRevision = c.getAfterRevision();
    if (contentRevision != null && !contentRevision.getFile().isDirectory()) {
      return true;
    }
  }
  return false;
}
 

@Nonnull
public AnalysisScope getScope(@Nonnull AnalysisUIOptions uiOptions, @Nonnull AnalysisScope defaultScope, @Nonnull Project project, Module module) {
  AnalysisScope scope;
  if (isProjectScopeSelected()) {
    scope = new AnalysisScope(project);
    uiOptions.SCOPE_TYPE = AnalysisScope.PROJECT;
  }
  else {
    final SearchScope customScope = getCustomScope();
    if (customScope != null) {
      scope = new AnalysisScope(customScope, project);
      uiOptions.SCOPE_TYPE = AnalysisScope.CUSTOM;
      uiOptions.CUSTOM_SCOPE_NAME = customScope.getDisplayName();
    }
    else if (isModuleScopeSelected()) {
      scope = new AnalysisScope(module);
      uiOptions.SCOPE_TYPE = AnalysisScope.MODULE;
    }
    else if (isUncommitedFilesSelected()) {
      final ChangeListManager changeListManager = ChangeListManager.getInstance(project);
      List<VirtualFile> files;
      if (myChangeLists.getSelectedItem() == ALL) {
        files = changeListManager.getAffectedFiles();
      }
      else {
        files = new ArrayList<VirtualFile>();
        for (ChangeList list : changeListManager.getChangeListsCopy()) {
          if (!Comparing.strEqual(list.getName(), (String)myChangeLists.getSelectedItem())) continue;
          final Collection<Change> changes = list.getChanges();
          for (Change change : changes) {
            final ContentRevision afterRevision = change.getAfterRevision();
            if (afterRevision != null) {
              final VirtualFile vFile = afterRevision.getFile().getVirtualFile();
              if (vFile != null) {
                files.add(vFile);
              }
            }
          }
        }
      }
      scope = new AnalysisScope(project, new HashSet<VirtualFile>(files));
      uiOptions.SCOPE_TYPE = AnalysisScope.UNCOMMITTED_FILES;
    }
    else {
      scope = defaultScope;
      uiOptions.SCOPE_TYPE = defaultScope.getScopeType();//just not project scope
    }
  }
  uiOptions.ANALYZE_TEST_SOURCES = isInspectTestSources();
  scope.setIncludeTestSource(isInspectTestSources());
  scope.setScope(getCustomScope());

  FindSettings.getInstance().setDefaultScopeName(scope.getDisplayName());
  return scope;
}
 

@Nullable
public List<VcsException> commit(final List<Change> changes,
                                 final String preparedComment,
                                 @NotNull NullableFunction<Object, Object> parametersHolder, Set<String> feedback) {
    final List<VcsException> errors = new ArrayList<VcsException>();

    // set progress bar status
    final ProgressIndicator progressIndicator = ProgressManager.getInstance().getProgressIndicator();
    TFSProgressUtil.setProgressText(progressIndicator, TfPluginBundle.message(TfPluginBundle.KEY_TFVC_CHECKIN_STATUS));

    // find files that are to be checked in
    final List<String> files = new ArrayList<String>();
    for (final Change change : changes) {
        String path = null;
        final ContentRevision beforeRevision = change.getBeforeRevision();
        final ContentRevision afterRevision = change.getAfterRevision();
        if (afterRevision != null) {
            path = afterRevision.getFile().getPath();
        } else if (beforeRevision != null) {
            path = beforeRevision.getFile().getPath();
        }
        if (path != null) {
            files.add(path);
        }
    }

    try {
        final ServerContext context = myVcs.getServerContext(true);
        final List<Integer> workItemIds = VcsHelper.getWorkItemIdsFromMessage(preparedComment);
        final String changesetNumber = CommandUtils.checkinFiles(context, files, preparedComment, workItemIds);

        // notify user of success
        final String changesetLink = String.format(UrlHelper.SHORT_HTTP_LINK_FORMATTER, UrlHelper.getTfvcChangesetURI(context.getUri().toString(), changesetNumber),
                TfPluginBundle.message(TfPluginBundle.KEY_TFVC_CHECKIN_LINK_TEXT, changesetNumber));
        VcsNotifier.getInstance(myVcs.getProject()).notifyImportantInfo(TfPluginBundle.message(TfPluginBundle.KEY_TFVC_CHECKIN_SUCCESSFUL_TITLE),
                TfPluginBundle.message(TfPluginBundle.KEY_TFVC_CHECKIN_SUCCESSFUL_MSG, changesetLink), new NotificationListener() {
                    @Override
                    public void hyperlinkUpdate(@NotNull Notification notification, @NotNull HyperlinkEvent hyperlinkEvent) {
                        BrowserUtil.browse(hyperlinkEvent.getURL());
                    }
                });
    } catch (Exception e) {
        // no notification needs to be done by us for errors, IntelliJ handles that
        logger.warn("Error during checkin", e);
        if (e instanceof TeamServicesException) {
            // get localized message in the case of TeamServicesException otherwise the key will print out instead of the error
            errors.add(new VcsException(LocalizationServiceImpl.getInstance().getExceptionMessage(e)));
        } else {
            errors.add(new VcsException(e));
        }
    }

    return errors;
}
 

@Nullable
private static VirtualFile getVfFromChange(@Nonnull Change change) {
  ContentRevision after = change.getAfterRevision();
  return after != null ? after.getFile().getVirtualFile() : null;
}
 

private static boolean seemsToBeMoved(Change change, VirtualFile toSelect) {
  ContentRevision afterRevision = change.getAfterRevision();
  if (afterRevision == null) return false;
  FilePath file = afterRevision.getFile();
  return FileUtil.pathsEqual(file.getPath(), toSelect.getPath());
}
 

public DiffRequestPresentable convert(final Change ch, final boolean forceText) {
  if (ch.hasOtherLayers() && myRecursive) {
    return new MultipleDiffRequestPresentable(myProject, ch);
  }
  if (ChangesUtil.isTextConflictingChange(ch)) {
    final AbstractVcs vcs = ChangesUtil.getVcsForChange(ch, myProject);
    final MergeProvider mergeProvider = vcs.getMergeProvider();
    if (mergeProvider == null) return null;
    final FilePath path = ChangesUtil.getFilePath(ch);
    VirtualFile vf = path.getVirtualFile();
    if (vf == null) {
      path.hardRefresh();
      vf = path.getVirtualFile();
    }
    if (vf == null) return null;

    return new ConflictedDiffRequestPresentable(myProject, vf, ch);
  } else {
    if (forceText) {
      if (ch.getBeforeRevision() != null && ch.getAfterRevision() != null) {
        try {
          if (StringUtil.isEmptyOrSpaces(ch.getBeforeRevision().getContent()) &&
              StringUtil.isEmptyOrSpaces(ch.getAfterRevision().getContent())) {
            return null;
          }
          if (StringUtil.equals(ch.getBeforeRevision().getContent(), ch.getAfterRevision().getContent())) {
            return null;
          }
        }
        catch (VcsException e) {
          //
        }
      }
    }
    final ChangeDiffRequestPresentable presentable = new ChangeDiffRequestPresentable(myProject, ch);
    if (forceText) {
      presentable.setIgnoreDirectoryFlag(true);
    }
    return presentable;
  }
}
 

@Override
public boolean afterNull(Change change) {
  return change.getAfterRevision() == null;
}
 

@Override
public boolean beforeNull(Change change) {
  return change.getAfterRevision() == null;
}
 

public static boolean isChangeForFolder(Change change) {
  ContentRevision revB = change.getBeforeRevision();
  ContentRevision revA = change.getAfterRevision();
  return (revA != null && revA.getFile().isDirectory()) || (revB != null && revB.getFile().isDirectory());
}
 

/**
 * @param change "Change" description.
 * @return Return true if the "Change" object is created for "Delete" operation:
 *         "before" revision is NOT NULL, while "after" revision is NULL.
 */
public static boolean isChangeForDeleted(Change change) {
  return (change.getBeforeRevision() != null) && (change.getAfterRevision() == null);
}
 

/**
 * @param change "Change" description.
 * @return Return true if the "Change" object is created for "New" operation:
 *         "before" revision is obviously NULL, while "after" revision is not.
 */
public static boolean isChangeForNew(Change change) {
  return (change.getBeforeRevision() == null) && (change.getAfterRevision() != null);
}