plugins/cvs/cvs-plugin/src/com/intellij/cvsSupport2/annotate/CvsAnnotationProvider.java

/*
 * Copyright 2000-2014 JetBrains s.r.o.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.intellij.cvsSupport2.annotate;

import com.intellij.CvsBundle;
import com.intellij.cvsSupport2.CvsUtil;
import com.intellij.cvsSupport2.application.CvsEntriesManager;
import com.intellij.cvsSupport2.connections.CvsConnectionSettings;
import com.intellij.cvsSupport2.connections.CvsEnvironment;
import com.intellij.cvsSupport2.cvsExecution.CvsOperationExecutor;
import com.intellij.cvsSupport2.cvsExecution.CvsOperationExecutorCallback;
import com.intellij.cvsSupport2.cvshandlers.CommandCvsHandler;
import com.intellij.cvsSupport2.cvsoperations.cvsAnnotate.AnnotateOperation;
import com.intellij.cvsSupport2.cvsoperations.cvsAnnotate.Annotation;
import com.intellij.cvsSupport2.history.CvsHistoryProvider;
import com.intellij.cvsSupport2.history.CvsRevisionNumber;
import com.intellij.openapi.cvsIntegration.CvsResult;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vcs.FilePath;
import com.intellij.openapi.vcs.RepositoryLocation;
import com.intellij.openapi.vcs.VcsException;
import com.intellij.openapi.vcs.actions.VcsContextFactory;
import com.intellij.openapi.vcs.annotate.AnnotationProvider;
import com.intellij.openapi.vcs.annotate.FileAnnotation;
import com.intellij.openapi.vcs.history.VcsFileRevision;
import com.intellij.openapi.vcs.history.VcsRevisionNumber;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.util.ArrayUtil;
import org.jetbrains.annotations.NonNls;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
import org.netbeans.lib.cvsclient.admin.Entry;

import java.io.File;
import java.io.IOException;
import java.util.*;

public class CvsAnnotationProvider implements AnnotationProvider{

  @NonNls private static final String INVALID_OPTION_F = "invalid option -- F";
  @NonNls private static final String USAGE_CVSNTSRV_SERVER = "Usage: cvs";
  private static final Collection<String> ourDoNotAnnotateBinaryRoots = new HashSet<String>();

  private final Project myProject;
  private final CvsHistoryProvider myCvsHistoryProvider;

  public CvsAnnotationProvider(final Project project, CvsHistoryProvider cvsHistoryProvider) {
    myProject = project;
    myCvsHistoryProvider = cvsHistoryProvider;
  }

  public FileAnnotation annotate(VirtualFile virtualFile) throws VcsException {
    final File file = new File(virtualFile.getPath());
    final File cvsLightweightFile = CvsUtil.getCvsLightweightFileForFile(file);
    final String revision = CvsUtil.getRevisionFor(file);
    final CvsEntriesManager entriesManager = CvsEntriesManager.getInstance();
    final CvsConnectionSettings root = entriesManager.getCvsConnectionSettingsFor(file.getParentFile());
    final boolean binary = annotateBinary(virtualFile, root);
    final AnnotateOperation operation = executeOperation(cvsLightweightFile, revision, root, binary, true);

    final FilePath filePath = VcsContextFactory.SERVICE.getInstance().createFilePathOn(virtualFile);
    final List<VcsFileRevision> revisions = myCvsHistoryProvider.createRevisions(filePath);
    final Annotation[] lineAnnotations = operation.getLineAnnotations();
    adjustAnnotation(revisions, lineAnnotations);
    return new CvsFileAnnotation(operation.getContent(), lineAnnotations, revisions, virtualFile, revision, myProject);
  }

  public FileAnnotation annotate(VirtualFile file, VcsFileRevision revision) throws VcsException {
    final CvsConnectionSettings settings = CvsEntriesManager.getInstance().getCvsConnectionSettingsFor(file.getParent());
    return annotate(file, revision.getRevisionNumber().asString(), settings);
  }

  public boolean isAnnotationValid(VcsFileRevision rev){
    return true;
  }

  public FileAnnotation annotate(VirtualFile cvsVirtualFile, String revision, CvsEnvironment environment) throws VcsException {
    // the VirtualFile has a full path if annotate is called from history (when we have a real file on disk),
    // and has the path equal to a CVS module name if annotate is called from the CVS repository browser
    // (when there's no real path)
    boolean hasLocalFile = false;
    File cvsFile = new File(cvsVirtualFile.getPath());
    if (cvsFile.isAbsolute()) {
      hasLocalFile = true;
      cvsFile = new File(CvsUtil.getModuleName(cvsVirtualFile));
    }
    final boolean binary = annotateBinary(cvsVirtualFile, environment);
    final AnnotateOperation annotateOperation = executeOperation(cvsFile, revision, environment, binary, true);
    final Annotation[] lineAnnotations = annotateOperation.getLineAnnotations();
    final List<VcsFileRevision> revisions;
    if (hasLocalFile) {
      final FilePath filePath = VcsContextFactory.SERVICE.getInstance().createFilePathOn(cvsVirtualFile);
      revisions = myCvsHistoryProvider.createRevisions(filePath);
      // in annotation cvs returns only 8 symbols of username
      // try to find usernames in history and use them
      adjustAnnotation(revisions, lineAnnotations);
    }
    else {
      // imitation
      revisions = new ArrayList<VcsFileRevision>();
      final Set<String> usedRevisions = new HashSet<String>();
      for (Annotation annotation : lineAnnotations) {
        if (! usedRevisions.contains(annotation.getRevision())) {
          revisions.add(new RevisionPresentation(annotation.getRevision(), annotation.getUserName(), annotation.getDate()));
          usedRevisions.add(annotation.getRevision());
        }
      }
    }
    return new CvsFileAnnotation(annotateOperation.getContent(), lineAnnotations, revisions, cvsVirtualFile, revision, myProject);
  }

  private static boolean annotateBinary(VirtualFile cvsVirtualFile, CvsEnvironment environment) {
    if (ourDoNotAnnotateBinaryRoots.contains(environment.getCvsRootAsString())) {
      return false;
    }
    final Entry entry = CvsEntriesManager.getInstance().getEntryFor(cvsVirtualFile);
    if (entry != null) {
      return entry.isBinary();
    }
    return cvsVirtualFile.getFileType().isBinary();
  }

  private AnnotateOperation executeOperation(File file, String revision, CvsEnvironment root, boolean binary, boolean retryOnFailure)
    throws VcsException {
    final AnnotateOperation operation = new AnnotateOperation(file, revision, root, binary);
    final CvsOperationExecutor executor = new CvsOperationExecutor(myProject);
    executor.performActionSync(new CommandCvsHandler(CvsBundle.getAnnotateOperationName(), operation), CvsOperationExecutorCallback.EMPTY);
    final CvsResult result = executor.getResult();
    if (result.hasErrors()) {
      if (!retryOnFailure) {
        throw result.composeError();
      }
      for (VcsException error : result.getErrors()) {
        for (String message : error.getMessages()) {
          if (message.contains(INVALID_OPTION_F) || message.contains(USAGE_CVSNTSRV_SERVER)) {
            ourDoNotAnnotateBinaryRoots.add(root.getCvsRootAsString());
            return executeOperation(file, revision, root, false, false);
          }
        }
      }
      throw result.composeError();
    }
    return operation;
  }

  private static void adjustAnnotation(@Nullable List<VcsFileRevision> revisions, @NotNull Annotation[] lineAnnotations) {
    if (revisions != null) {
      final Map<String, VcsFileRevision> revisionMap = new HashMap<String, VcsFileRevision>();
      for (VcsFileRevision vcsFileRevision : revisions) {
        revisionMap.put(vcsFileRevision.getRevisionNumber().asString(), vcsFileRevision);
      }
      for (Annotation lineAnnotation : lineAnnotations) {
        final String revisionNumber = lineAnnotation.getRevision();
        final VcsFileRevision revision = revisionMap.get(revisionNumber);
        if (revision != null) {
          lineAnnotation.setUser(revision.getAuthor());
          lineAnnotation.setDate(revision.getRevisionDate());
        }
      }
    }
  }

  private static class RevisionPresentation implements VcsFileRevision {
    private final VcsRevisionNumber myNumber;
    private final String myAuthor;
    private final Date myDate;

    private RevisionPresentation(final String revision, final String author, final Date date) {
      myNumber = new CvsRevisionNumber(revision);
      myAuthor = author;
      myDate = date;
    }

    public VcsRevisionNumber getRevisionNumber() {
      return myNumber;
    }

    public String getBranchName() {
      return null;
    }

    public Date getRevisionDate() {
      return myDate;
    }

    public String getAuthor() {
      return myAuthor;
    }

    public String getCommitMessage() {
      return null;
    }

    @Nullable
    @Override
    public RepositoryLocation getChangedRepositoryPath() {
      return null;
    }

    public byte[] loadContent() throws IOException, VcsException {
      return getContent();
    }

    public byte[] getContent() throws IOException, VcsException {
      return ArrayUtil.EMPTY_BYTE_ARRAY;
    }
  }

}