Examples with VcsFileRevision com.intellij.openapi.vcs.history.VcsFileRevision used on opensource projects

Example 26 with VcsFileRevision

use of com.intellij.openapi.vcs.history.VcsFileRevision in project intellij-community by JetBrains.

the class GitFileAnnotation method getPreviousFileRevisionProvider.

@Nullable
@Override
public PreviousFileRevisionProvider getPreviousFileRevisionProvider() {
    return new PreviousFileRevisionProvider() {

        @Nullable
        @Override
        public VcsFileRevision getPreviousRevision(int lineNumber) {
            LineInfo lineInfo = getLineInfo(lineNumber);
            if (lineInfo == null)
                return null;
            VcsFileRevision previousFileRevision = lineInfo.getPreviousFileRevision();
            if (previousFileRevision != null)
                return previousFileRevision;
            GitRevisionNumber revisionNumber = lineInfo.getRevisionNumber();
            if (myRevisions != null && myRevisionMap != null && myRevisionMap.contains(revisionNumber)) {
                int index = myRevisionMap.get(revisionNumber);
                if (index + 1 < myRevisions.size()) {
                    return myRevisions.get(index + 1);
                }
            }
            return null;
        }

        @Nullable
        @Override
        public VcsFileRevision getLastRevision() {
            if (myBaseRevision instanceof GitRevisionNumber) {
                return new GitFileRevision(myProject, VcsUtil.getFilePath(myFile), (GitRevisionNumber) myBaseRevision);
            } else {
                return ContainerUtil.getFirstItem(getRevisions());
            }
        }
    };
}

Example 27 with VcsFileRevision

use of com.intellij.openapi.vcs.history.VcsFileRevision in project intellij-community by JetBrains.

the class GitDiffProvider method createFileContent.

/**
   * {@inheritDoc}
   */
@Nullable
public ContentRevision createFileContent(VcsRevisionNumber revisionNumber, VirtualFile selectedFile) {
    if (selectedFile.isDirectory()) {
        return null;
    }
    final String path = selectedFile.getPath();
    if (GitUtil.gitRootOrNull(selectedFile) == null) {
        return null;
    }
    // faster, if there were no renames
    FilePath filePath = VcsUtil.getFilePath(path);
    try {
        final CommittedChangesProvider committedChangesProvider = GitVcs.getInstance(myProject).getCommittedChangesProvider();
        final Pair<CommittedChangeList, FilePath> pair = committedChangesProvider.getOneList(selectedFile, revisionNumber);
        if (pair != null) {
            return GitContentRevision.createRevision(pair.getSecond(), revisionNumber, myProject, selectedFile.getCharset());
        }
    } catch (VcsException e) {
        GitVcs.getInstance(myProject).showErrors(Collections.singletonList(e), GitBundle.message("diff.find.error", path));
    }
    try {
        for (VcsFileRevision f : GitHistoryUtils.history(myProject, filePath)) {
            GitFileRevision gitRevision = (GitFileRevision) f;
            if (f.getRevisionNumber().equals(revisionNumber)) {
                return GitContentRevision.createRevision(gitRevision.getPath(), revisionNumber, myProject, selectedFile.getCharset());
            }
        }
        GitContentRevision candidate = (GitContentRevision) GitContentRevision.createRevision(filePath, revisionNumber, myProject, selectedFile.getCharset());
        try {
            candidate.getContent();
            return candidate;
        } catch (VcsException e) {
        // file does not exists
        }
    } catch (VcsException e) {
        GitVcs.getInstance(myProject).showErrors(Collections.singletonList(e), GitBundle.message("diff.find.error", path));
    }
    return null;
}

Example 28 with VcsFileRevision

use of com.intellij.openapi.vcs.history.VcsFileRevision in project intellij-community by JetBrains.

the class GithubOpenInBrowserAction method getDataFromHistory.

@Nullable
private static CommitData getDataFromHistory(AnActionEvent e) {
    Project project = e.getData(CommonDataKeys.PROJECT);
    FilePath filePath = e.getData(VcsDataKeys.FILE_PATH);
    VcsFileRevision fileRevision = e.getData(VcsDataKeys.VCS_FILE_REVISION);
    if (project == null || filePath == null || fileRevision == null)
        return null;
    if (!(fileRevision instanceof GitFileRevision))
        return null;
    GitRepository repository = GitUtil.getRepositoryManager(project).getRepositoryForFile(filePath);
    if (repository == null || !GithubUtil.isRepositoryOnGitHub(repository))
        return null;
    return new CommitData(project, repository, fileRevision.getRevisionNumber().asString());
}

Example 29 with VcsFileRevision

use of com.intellij.openapi.vcs.history.VcsFileRevision in project intellij-community by JetBrains.

the class AnnotateStackTraceAction method actionPerformed.

@Override
public void actionPerformed(final AnActionEvent e) {
    myIsLoading = true;
    ProgressManager.getInstance().run(new Task.Backgroundable(myEditor.getProject(), "Getting File History", true) {

        private final Object LOCK = new Object();

        private final MergingUpdateQueue myUpdateQueue = new MergingUpdateQueue("AnnotateStackTraceAction", 200, true, null);

        private MyActiveAnnotationGutter myGutter;

        @Override
        public void onCancel() {
            myEditor.getGutter().closeAllAnnotations();
        }

        @Override
        public void onFinished() {
            myIsLoading = false;
            Disposer.dispose(myUpdateQueue);
        }

        @Override
        public void run(@NotNull ProgressIndicator indicator) {
            MultiMap<VirtualFile, Integer> files2lines = new MultiMap<>();
            Map<Integer, LastRevision> revisions = ContainerUtil.newHashMap();
            ApplicationManager.getApplication().runReadAction(() -> {
                for (int line = 0; line < myEditor.getDocument().getLineCount(); line++) {
                    indicator.checkCanceled();
                    VirtualFile file = getHyperlinkVirtualFile(myHyperlinks.findAllHyperlinksOnLine(line));
                    if (file == null)
                        continue;
                    files2lines.putValue(file, line);
                }
            });
            files2lines.entrySet().forEach(entry -> {
                indicator.checkCanceled();
                VirtualFile file = entry.getKey();
                Collection<Integer> lines = entry.getValue();
                LastRevision revision = getLastRevision(file);
                if (revision == null)
                    return;
                synchronized (LOCK) {
                    for (Integer line : lines) {
                        revisions.put(line, revision);
                    }
                }
                myUpdateQueue.queue(new Update("update") {

                    @Override
                    public void run() {
                        updateGutter(indicator, revisions);
                    }
                });
            });
            // myUpdateQueue can be disposed before the last revisions are passed to the gutter
            ApplicationManager.getApplication().invokeLater(() -> updateGutter(indicator, revisions));
        }

        @CalledInAwt
        private void updateGutter(@NotNull ProgressIndicator indicator, @NotNull Map<Integer, LastRevision> revisions) {
            if (indicator.isCanceled())
                return;
            if (myGutter == null) {
                myGutter = new MyActiveAnnotationGutter(getProject(), myHyperlinks, indicator);
                myEditor.getGutter().registerTextAnnotation(myGutter, myGutter);
            }
            Map<Integer, LastRevision> revisionsCopy;
            synchronized (LOCK) {
                revisionsCopy = ContainerUtil.newHashMap(revisions);
            }
            myGutter.updateData(revisionsCopy);
            ((EditorGutterComponentEx) myEditor.getGutter()).revalidateMarkup();
        }

        @Nullable
        private LastRevision getLastRevision(@NotNull VirtualFile file) {
            try {
                AbstractVcs vcs = VcsUtil.getVcsFor(myEditor.getProject(), file);
                if (vcs == null)
                    return null;
                VcsHistoryProvider historyProvider = vcs.getVcsHistoryProvider();
                if (historyProvider == null)
                    return null;
                FilePath filePath = VcsContextFactory.SERVICE.getInstance().createFilePathOn(file);
                if (historyProvider instanceof VcsHistoryProviderEx) {
                    VcsFileRevision revision = ((VcsHistoryProviderEx) historyProvider).getLastRevision(filePath);
                    if (revision == null)
                        return null;
                    return LastRevision.create(revision);
                } else {
                    VcsHistorySession session = historyProvider.createSessionFor(filePath);
                    if (session == null)
                        return null;
                    List<VcsFileRevision> list = session.getRevisionList();
                    if (list == null || list.isEmpty())
                        return null;
                    return LastRevision.create(list.get(0));
                }
            } catch (VcsException ignored) {
                LOG.warn(ignored);
                return null;
            }
        }
    });
}

Example 30 with VcsFileRevision

use of com.intellij.openapi.vcs.history.VcsFileRevision in project intellij-community by JetBrains.

the class AnnotateVcsVirtualFileAction method extractData.

@Nullable
private static AnnotationData extractData(@NotNull Project project, @NotNull VirtualFile file) {
    FilePath filePath = null;
    VcsRevisionNumber revisionNumber = null;
    if (file instanceof VcsVirtualFile) {
        filePath = VcsUtil.getFilePath(file.getPath());
        VcsFileRevision revision = ((VcsVirtualFile) file).getFileRevision();
        revisionNumber = revision != null ? revision.getRevisionNumber() : null;
    } else if (file instanceof ContentRevisionVirtualFile) {
        ContentRevision revision = ((ContentRevisionVirtualFile) file).getContentRevision();
        filePath = revision.getFile();
        revisionNumber = revision.getRevisionNumber();
    }
    if (filePath == null || revisionNumber == null)
        return null;
    AbstractVcs vcs = VcsUtil.getVcsFor(project, filePath);
    return vcs != null ? new AnnotationData(vcs, filePath, revisionNumber) : null;
}