com.intellij.openapi.vcs.history.VcsFileRevision Java Examples

private static VcsAbstractHistorySession createSession(final VcsRevisionNumber currentRevisionNumber,
                                                       final List<TfsFileRevision> revisions,
                                                       final boolean isFile) {
    return new VcsAbstractHistorySession(revisions) {
        public VcsRevisionNumber calcCurrentRevisionNumber() {
            return currentRevisionNumber;
        }

        public HistoryAsTreeProvider getHistoryAsTreeProvider() {
            return null;
        }

        @Override
        public VcsHistorySession copy() {
            return createSession(currentRevisionNumber, revisions, isFile);
        }

        @Override
        public boolean isContentAvailable(final VcsFileRevision revision) {
            return isFile;
        }
    };
}
 

@Nullable
@Override
public VcsHistorySession createSessionFor(FilePath filePath) throws VcsException {
    ClientConfigRoot root = getRootFor(filePath);
    if (root == null) {
        LOG.info("Not in P4 project: " + filePath);
        return null;
    }

    try {
        List<VcsFileRevision> revisions = P4ServerComponent
                .query(project, root.getClientConfig(),
                        new ListFileHistoryQuery(filePath, -1))
                .blockingGet(UserProjectPreferences.getLockWaitTimeoutMillis(project), TimeUnit.MILLISECONDS)
                .getRevisions(formatter, loader);
        return createAppendableSession(filePath, revisions, null);
    } catch (InterruptedException e) {
        throw new VcsInterruptedException(e);
    }
}
 

@Override
@Nullable
public VcsFileRevision getLastRevision(FilePath filePath)
        throws VcsException {
    ClientConfigRoot root = getRootFor(filePath);
    if (root == null) {
        LOG.info("File not under vcs: " + filePath);
        return null;
    }

    try {
        List<VcsFileRevision> revisions = getHistory(root, filePath, 1)
                .blockingGet(UserProjectPreferences.getLockWaitTimeoutMillis(project), TimeUnit.MILLISECONDS)
                .getRevisions(formatter, loader);
        if (revisions.isEmpty()) {
            if (LOG.isDebugEnabled()) {
                LOG.debug("no revisions found for " + filePath);
            }
            return null;
        }
        return revisions.get(0);
    } catch (InterruptedException e) {
        InternalErrorMessage.send(project).cacheLockTimeoutError(new ErrorEvent<>(new VcsInterruptedException(e)));
        return null;
    }
}
 

@Nullable
@Override
protected VirtualFile getFile(@Nonnull AnActionEvent e) {
  VcsFileRevision revision = getFileRevision(e);
  if (revision == null) return null;

  final FileType currentFileType = myAnnotation.getFile().getFileType();
  FilePath filePath = (revision instanceof VcsFileRevisionEx ? ((VcsFileRevisionEx)revision).getPath() : VcsUtil.getFilePath(myAnnotation.getFile()));
  return new VcsVirtualFile(filePath.getPath(), revision, VcsFileSystem.getInstance()) {
    @Nonnull
    @Override
    public FileType getFileType() {
      FileType type = super.getFileType();
      if (!type.isBinary()) return type;
      if (!currentFileType.isBinary()) return currentFileType;
      return PlainTextFileType.INSTANCE;
    }
  };
}
 

public AnnotatePreviousRevisionAction(@Nonnull FileAnnotation annotation, @Nonnull AbstractVcs vcs) {
  super("Annotate Previous Revision", "Annotate successor of selected revision in new tab", AllIcons.Actions.Annotate,
        annotation, vcs);
  List<VcsFileRevision> revisions = annotation.getRevisions();
  if (revisions == null) {
    myRevisions = null;
    return;
  }

  Map<VcsRevisionNumber, VcsFileRevision> map = new HashMap<VcsRevisionNumber, VcsFileRevision>();
  for (int i = 0; i < revisions.size(); i++) {
    VcsFileRevision revision = revisions.get(i);
    VcsFileRevision previousRevision = i + 1 < revisions.size() ? revisions.get(i + 1) : null;
    map.put(revision.getRevisionNumber(), previousRevision);
  }

  myRevisions = new ArrayList<VcsFileRevision>(annotation.getLineCount());
  for (int i = 0; i < annotation.getLineCount(); i++) {
    myRevisions.add(map.get(annotation.getLineRevisionNumber(i)));
  }
}
 

public AnnotateCurrentRevisionAction(@Nonnull FileAnnotation annotation, @Nonnull AbstractVcs vcs) {
  super("Annotate Revision", "Annotate selected revision in new tab", AllIcons.Actions.Annotate,
        annotation, vcs);
  List<VcsFileRevision> revisions = annotation.getRevisions();
  if (revisions == null) {
    myRevisions = null;
    return;
  }

  Map<VcsRevisionNumber, VcsFileRevision> map = new HashMap<VcsRevisionNumber, VcsFileRevision>();
  for (VcsFileRevision revision : revisions) {
    map.put(revision.getRevisionNumber(), revision);
  }

  myRevisions = new ArrayList<VcsFileRevision>(annotation.getLineCount());
  for (int i = 0; i < annotation.getLineCount(); i++) {
    myRevisions.add(map.get(annotation.getLineRevisionNumber(i)));
  }
}
 

/**
 * Get all revisions that are mentioned in the annotations
 *
 * @return the list of revisions that are mentioned in annotations. Or null
 * if before/after popups cannot be supported by the VCS system.
 */
@Nullable
@Override
public List<VcsFileRevision> getRevisions() {

    // Possibly look into using P4HistoryProvider#getHistory instead,
    // however that wouldn't conform to the API.

    Set<VcsFileRevision> revs = new HashSet<>();
    for (P4AnnotatedLine line : annotatedFile.getAnnotatedLines()) {
        if (line != null) {
            P4HistoryVcsFileRevision fileRev = new P4HistoryVcsFileRevision(
                    file, config, line.getRevisionData(), formatter, loader);
            revs.add(fileRev);
        }
    }
    LOG.debug("getRevisions(): " + revs.size() + " " + revs);
    return new ArrayList<>(revs);
}
 

private Pair<OptionalClientServerConfig, P4ChangelistId> findAttachedFileRevision(AnActionEvent e) {
    final VirtualFile file;
    {
        final Boolean nonLocal = e.getData(VcsDataKeys.VCS_NON_LOCAL_HISTORY_SESSION);
        if (Boolean.TRUE.equals(nonLocal)) {
            LOG.info("non-local VCS history session; ignoring changelist description action");
            return null;
        }
        file = e.getData(VcsDataKeys.VCS_VIRTUAL_FILE);
        if (file == null || file.isDirectory()) {
            LOG.info("No VCS virtual file associated with changelist description action; ignoring request.");
            return null;
        }
    }

    final VcsFileRevision revision = e.getData(VcsDataKeys.VCS_FILE_REVISION);
    if (!(revision instanceof P4HistoryVcsFileRevision)) {
        LOG.info("No file revision associated with file " + file);
        return null;
    }
    P4HistoryVcsFileRevision history = (P4HistoryVcsFileRevision) revision;
    return Pair.create(new OptionalClientServerConfig(history.getClientConfig()), history.getChangelistId());
}
 

private void initShowComments(final List<VcsFileRevision> revisions) {
  for (VcsFileRevision revision : revisions) {
    if (revision.getCommitMessage() != null) {
      myShowComments = true;
      return;
    }
  }
  myShowComments = false;
}
 

public VcsAnnotation(FilePath filePath, VcsLineAnnotationData basicAnnotation, VcsRevisionNumber lastRevision) {
  myBasicAnnotation = basicAnnotation;
  myLastRevision = lastRevision;
  myAdditionalAnnotations = new HashMap<Object, VcsLineAnnotationData>();
  myCachedOtherRevisions = new HashMap<VcsRevisionNumber, VcsFileRevision>();
  myFilePath = filePath;
}
 

@Nullable
private static PreviousFileRevisionProvider createDefaultPreviousFileRevisionProvider(@Nonnull FileAnnotation annotation) {
  List<VcsFileRevision> revisions = annotation.getRevisions();
  if (revisions == null) return null;

  Map<VcsRevisionNumber, VcsFileRevision> map = new HashMap<>();
  for (int i = 0; i < revisions.size(); i++) {
    VcsFileRevision revision = revisions.get(i);
    VcsFileRevision previousRevision = i + 1 < revisions.size() ? revisions.get(i + 1) : null;
    map.put(revision.getRevisionNumber(), previousRevision);
  }

  List<VcsFileRevision> lineToRevision = new ArrayList<>(annotation.getLineCount());
  for (int i = 0; i < annotation.getLineCount(); i++) {
    lineToRevision.add(map.get(annotation.getLineRevisionNumber(i)));
  }

  VcsFileRevision lastRevision = ContainerUtil.getFirstItem(revisions);

  return new PreviousFileRevisionProvider() {
    @javax.annotation.Nullable
    @Override
    public VcsFileRevision getPreviousRevision(int lineNumber) {
      LOG.assertTrue(lineNumber >= 0 && lineNumber < lineToRevision.size());
      return lineToRevision.get(lineNumber);
    }

    @javax.annotation.Nullable
    @Override
    public VcsFileRevision getLastRevision() {
      return lastRevision;
    }
  };
}
 

public HighlightAnnotationsActions(final Project project, final VirtualFile virtualFile, final FileAnnotation fileAnnotation,
                                   final EditorGutterComponentEx gutter) {
  myGutter = gutter;
  myBefore = new HightlightAction(true, project, virtualFile, fileAnnotation, myGutter, null);
  final List<VcsFileRevision> fileRevisionList = fileAnnotation.getRevisions();
  final VcsFileRevision afterSelected = ((fileRevisionList != null) && (fileRevisionList.size() > 1)) ? fileRevisionList.get(0) : null;
  myAfter = new HightlightAction(false, project, virtualFile, fileAnnotation, myGutter, afterSelected);
  myRemove = new RemoveHighlightingAction();
}
 

private HightlightAction(final boolean before, final Project project, final VirtualFile virtualFile, final FileAnnotation fileAnnotation,
                         final EditorGutterComponentEx gutter, @javax.annotation.Nullable final VcsFileRevision selectedRevision) {
  myBefore = before;
  myProject = project;
  myVirtualFile = virtualFile;
  myFileAnnotation = fileAnnotation;
  myGutter = gutter;
  myShowComments = null;
  mySelectedRevision = selectedRevision;
}
 

public void actionPerformed(final AnActionEvent e) {
  final List<VcsFileRevision> fileRevisionList = myFileAnnotation.getRevisions();
  if (fileRevisionList != null) {
    if (myShowComments == null) {
      initShowComments(fileRevisionList);
    }
    CompareWithSelectedRevisionAction.showListPopup(fileRevisionList, myProject,
                                                    new Consumer<VcsFileRevision>() {
                                                      public void consume(final VcsFileRevision vcsFileRevision) {
                                                        mySelectedRevision = vcsFileRevision;
                                                        myGutter.revalidateMarkup();
                                                      }
                                                    }, myShowComments.booleanValue());
  }
}
 

@Override
public void actionPerformed(AnActionEvent e) {
  final Project project = e.getData(CommonDataKeys.PROJECT);
  if (project == null) return;
  final VcsKey vcsKey = e.getData(VcsDataKeys.VCS);
  if (vcsKey == null) return;
  final VcsFileRevision revision = e.getData(VcsDataKeys.VCS_FILE_REVISION);
  VirtualFile revisionVirtualFile = e.getData(VcsDataKeys.VCS_VIRTUAL_FILE);
  final Boolean isNonLocal = e.getData(VcsDataKeys.VCS_NON_LOCAL_HISTORY_SESSION);
  if ((revision != null) && (revisionVirtualFile != null)) {
    showSubmittedFiles(project, revision.getRevisionNumber(), revisionVirtualFile, vcsKey, revision.getChangedRepositoryPath(),
                       Boolean.TRUE.equals(isNonLocal));
  }
}
 

@javax.annotation.Nullable
private static Map<VcsRevisionNumber, Integer> computeLineNumbers(@Nonnull FileAnnotation fileAnnotation) {
  final Map<VcsRevisionNumber, Integer> numbers = new HashMap<>();
  final List<VcsFileRevision> fileRevisionList = fileAnnotation.getRevisions();
  if (fileRevisionList != null) {
    int size = fileRevisionList.size();
    for (int i = 0; i < size; i++) {
      VcsFileRevision revision = fileRevisionList.get(i);
      final VcsRevisionNumber number = revision.getRevisionNumber();

      numbers.put(number, size - i);
    }
  }
  return numbers.size() < 2 ? null : numbers;
}
 

@Nullable
@Override
protected VcsFileRevision getFileRevision(@Nonnull AnActionEvent e) {
  List<VcsFileRevision> revisions = getRevisions();
  assert revisions != null;

  if (currentLine < 0 || currentLine >= revisions.size()) return null;
  return revisions.get(currentLine);
}
 

@Nonnull
public static LastRevision create(@Nonnull VcsFileRevision revision) {
  VcsRevisionNumber number = revision.getRevisionNumber();
  String author = StringUtil.notNullize(revision.getAuthor(), "Unknown");
  Date date = revision.getRevisionDate();
  String message = StringUtil.notNullize(revision.getCommitMessage());
  return new LastRevision(number, author, date, message);
}
 

@Override
public void showDiffForTwo(@NotNull Project project,
        @NotNull FilePath filePath,
        @NotNull VcsFileRevision revision1,
        @NotNull VcsFileRevision revision2) {
    VcsHistoryUtil.showDifferencesInBackground(project, filePath, revision1, revision2);
}
 

@NotNull
private ListFileHistoryResult.VcsFileRevisionFactory createFileHistoryList(
        @NotNull final ClientConfig config,
        @NotNull final FilePath file,
        @NotNull final List<IFileRevisionData> history) {
    return (formatter, loader) -> {
        List<VcsFileRevision> ret = new ArrayList<>(history.size());
        history.forEach((d) -> {
            P4HistoryVcsFileRevision rev = new P4HistoryVcsFileRevision(
                    file, config, d, formatter, loader);
            ret.add(rev);
        });
        return ret;
    };
}
 

Integer getDataOf(VcsFileRevision rev) {
    if (rev instanceof P4FileRevision) {
        return ((P4FileRevision) rev).getChangelistId().getChangelistId();
    }
    if (rev instanceof P4HistoryVcsFileRevision) {
        return ((P4HistoryVcsFileRevision) rev).getChangelistId().getChangelistId();
    }
    return null;
}
 

public List<VcsFileRevision> getRevisions(@Nullable HistoryMessageFormatter formatter,
        @Nullable HistoryContentLoader loader) {
    return factory.create(formatter, loader);
}
 

@NotNull
@Override
public FileAnnotation annotate(@NotNull VirtualFile file, VcsFileRevision revision) throws VcsException {
    if (ApplicationManager.getApplication().isDispatchThread()) {
        LOG.info("Fetching annotation from the EDT");
        // TODO bundle for error messages
        throw new VcsException("Does not support fetching annotations from the EDT.");
    }
    // TODO use a better location for this constant.
    int rev = IFileSpec.HEAD_REVISION;
    if (revision != null) {
        VcsRevisionNumber revNumber = revision.getRevisionNumber();
        if (revNumber instanceof VcsRevisionNumber.Int) {
            rev = ((VcsRevisionNumber.Int) revNumber).getValue();
        } else {
            LOG.warn("Unknown file revision " + revision + " for " + file + "; using head revision");
        }
    }
    FilePath fp = VcsUtil.getFilePath(file);
    if (fp == null) {
        // TODO bundle for error messages
        throw new VcsException("No known Perforce server for " + file);
    }
    ProjectConfigRegistry registry = ProjectConfigRegistry.getInstance(project);
    if (registry == null) {
        // TODO bundle for error messages
        throw new VcsException("Project not configured for showing annotations");
    }
    ClientConfigRoot client = registry.getClientFor(file);
    if (client == null) {
        // TODO bundle for error messages
        throw new VcsException("No known Perforce server for " + file);
    }
    String clientname = client.getClientConfig().getClientname();
    if (clientname == null) {
        // TODO bundle for error messages
        throw new VcsException("No workspace name set for Perforce connection for " + file);
    }
    try {
        return new P4AnnotatedFileImpl(project, fp,
                messageFormatter, contentLoader,
                P4ServerComponent
                    .query(project, client.getClientConfig(), new AnnotateFileQuery(fp, rev))
                    .blockingGet(UserProjectPreferences.getLockWaitTimeoutMillis(project), TimeUnit.MILLISECONDS));
    } catch (InterruptedException e) {
        throw new VcsInterruptedException(e);
    }
}
 

@Override
public void showDiffForOne(@NotNull AnActionEvent e, @NotNull Project project, @NotNull FilePath filePath,
        @NotNull VcsFileRevision previousRevision, @NotNull VcsFileRevision revision) {
    VcsHistoryUtil.showDifferencesInBackground(project, filePath, previousRevision, revision);
}
 

@Nullable
protected abstract List<VcsFileRevision> getRevisions();
 

public boolean isEnabled(@Nonnull AnActionEvent e) {
  if (e.getProject() == null) return false;

  VcsFileRevision fileRevision = getFileRevision(e);
  if (fileRevision == null) return false;

  VirtualFile file = getFile(e);
  if (file == null) return false;

  AbstractVcs vcs = getVcs(e);
  if (vcs == null) return false;

  AnnotationProvider provider = vcs.getAnnotationProvider();
  if (provider == null || !provider.isAnnotationValid(fileRevision)) return false;

  if (VcsAnnotateUtil.getBackgroundableLock(vcs.getProject(), file).isLocked()) return false;

  return true;
}
 

@Nullable
protected abstract VcsFileRevision getFileRevision(@Nonnull AnActionEvent e);
 

@Override
@Nullable
public List<VcsFileRevision> getRevisions() {
  return myRevisions;
}
 

@Override
@Nullable
public List<VcsFileRevision> getRevisions() {
  return myRevisions;
}
 

public Comparator<VcsFileRevision> getComparator() {
    return this;
}