com.intellij.vcs.log.Hash Java Examples

private void mockGitRepoInfo(GitRemoteBranch... remoteBranches) {
    HashMap<GitRemoteBranch, Hash> remoteBranchMap = Maps.newHashMap();
    for (GitRemoteBranch remoteBranch : remoteBranches) {
        remoteBranchMap.put(remoteBranch, null);
    }

    GitRepoInfo gitRepoInfo = new GitRepoInfo(
            null,
            null,
            Repository.State.NORMAL,
            Collections.emptyList(),
            Collections.emptyMap(),
            remoteBranchMap,
            Collections.emptyList(),
            Collections.emptyList(),
            new GitHooksInfo(false, false),
            false
    );
    when(mockGitRepository.getInfo()).thenReturn(gitRepoInfo);
}
 

private void mockGitRepoBranches(GitLocalBranch currentBranch, GitRemoteBranch... remoteBranches) {
    HashMap<GitRemoteBranch, Hash> remoteBranchMap = Maps.newHashMap();
    for (GitRemoteBranch remoteBranch : remoteBranches) {
        remoteBranchMap.put(remoteBranch, null);
    }

    GitRepoInfo gitRepoInfo = new GitRepoInfo(
            currentBranch,
            null,
            Repository.State.NORMAL,
            Collections.emptyList(),
            Collections.emptyMap(),
            remoteBranchMap,
            Collections.emptyList(),
            Collections.emptyList(),
            new GitHooksInfo(false, false),
            false
    );
    when(gitRepositoryMock.getInfo()).thenReturn(gitRepoInfo);
}
 

private RepoStatusRemote createRemoteStatus(@NotNull GitRepository repository, @NotNull GitLocalBranch localBranch) {
  GitToolBoxConfigPrj config = ProjectConfig.get(project);
  GitRemoteBranch trackedBranch = localBranch.findTrackedBranch(repository);
  GitRemoteBranch parentBranch = null;
  GitRepoInfo repoInfo = repository.getInfo();
  ReferencePointForStatusType type = config.getReferencePointForStatus().getType();
  if (type == ReferencePointForStatusType.TRACKED_REMOTE_BRANCH) {
    parentBranch = trackedBranch;
  } else if (type == ReferencePointForStatusType.SELECTED_PARENT_BRANCH) {
    parentBranch = findRemoteParent(repository, config.getReferencePointForStatus().getName()).orElse(null);
  } else if (type == ReferencePointForStatusType.AUTOMATIC) {
    parentBranch = getRemoteBranchFromActiveTask(repository).orElse(trackedBranch);
  }

  Hash parentHash = repoInfo.getRemoteBranchesWithHashes()
                        .get(parentBranch);
  return new RepoStatusRemote(trackedBranch, parentBranch, parentHash);
}
 

public VcsChangesLazilyParsedDetails(@Nonnull Hash hash, @Nonnull List<Hash> parents, long commitTime, @Nonnull VirtualFile root,
                                     @Nonnull String subject, @Nonnull VcsUser author, @Nonnull String message,
                                     @Nonnull VcsUser committer, long authorTime,
                                     @Nonnull ThrowableComputable<Collection<Change>, ? extends Exception> changesGetter) {
  super(hash, parents, commitTime, root, subject, author, message, committer, authorTime);
  myChangesGetter = changesGetter;
}
 

@Nonnull
public static Hash read(@Nonnull DataInput in) throws IOException {
  int length = DataInputOutputUtil.readINT(in);
  if (length == 0) throw new IOException("Can not read hash: data length is zero");
  byte[] buf = new byte[length];
  in.readFully(buf);
  return new HashImpl(buf);
}
 

public VcsShortCommitDetailsImpl(@Nonnull Hash hash, @Nonnull List<Hash> parents, long commitTime, @Nonnull VirtualFile root,
                                 @Nonnull String subject, @Nonnull VcsUser author, @Nonnull VcsUser committer, long authorTime) {
  super(hash, parents, commitTime);
  myRoot = root;
  mySubject = subject;
  myAuthor = author;
  myCommitter = committer;
  myAuthorTime = authorTime;
}
 

public VcsRefImpl(@Nonnull Hash commitHash, @Nonnull String name, @Nonnull VcsRefType type, @Nonnull VirtualFile root) {
  myCommitHash = commitHash;
  myType = type;
  myRoot = root;
  synchronized (ourNames) {
    myName = ourNames.intern(name);
  }
}
 

public GraphColorManagerImpl(@Nonnull RefsModel refsModel,
                             @Nonnull Function<Integer, Hash> hashGetter,
                             @Nonnull Map<VirtualFile, VcsLogRefManager> refManagers) {
  myRefsModel = refsModel;

  myHeadsComparator = new HeadsComparator(refsModel, refManagers, hashGetter);
}
 

public HeadsComparator(@Nonnull RefsModel refsModel,
                       @Nonnull Map<VirtualFile, VcsLogRefManager> refManagers,
                       @Nonnull Function<Integer, Hash> hashGetter) {
  myRefsModel = refsModel;
  myRefManagers = refManagers;
  myHashGetter = hashGetter;
}
 

private List<String> calculateTags(@NotNull GitRepository repository, @Nullable Hash localHash) {
  GitTagCalculator tagCalculator = GitTagCalculator.create(repository.getProject());
  if (localHash == null) {
    return tagCalculator.tagsForHead(repository.getRoot());
  } else {
    return tagCalculator.tagsForCommit(repository.getRoot(), localHash);
  }
}
 

@NotNull
RepoStatus createRepoStatus(@NotNull GitRepository repository) {
  Hash localHash = null;
  RepoStatusRemote remote = RepoStatusRemote.empty();

  GitLocalBranch localBranch = repository.getCurrentBranch();
  if (localBranch != null) {
    GitRepoInfo repoInfo = repository.getInfo();
    localHash = repoInfo.getLocalBranchesWithHashes()
                    .get(localBranch);
    remote = createRemoteStatus(repository, localBranch);
  }

  return RepoStatus.create(localBranch, localHash, remote);
}
 

@NotNull
public GitAheadBehindCount aheadBehindStatus(@NotNull GitRepository repository, @Nullable Hash localHash,
                                             @Nullable Hash remoteHash) {
  if (localHash != null && remoteHash != null) {
    return doRevListLeftRight(localHash.asString(), remoteHash.asString(), repository);
  } else {
    return GitAheadBehindCount.noRemote();
  }
}
 

@Override
public void update(@Nonnull AnActionEvent e) {
  super.update(e);
  e.getPresentation().setVisible(true);

  final VcsLog log = e.getData(VcsLogDataKeys.VCS_LOG);
  Project project = e.getProject();
  if (project == null) {
    e.getPresentation().setEnabledAndVisible(false);
    return;
  }
  VcsCherryPickManager cherryPickManager = VcsCherryPickManager.getInstance(project);

  List<VcsCherryPicker> cherryPickers = getActiveCherryPickersForProject(project);
  if (log == null || cherryPickers.isEmpty()) {
    e.getPresentation().setEnabledAndVisible(false);
    return;
  }

  List<CommitId> commits = VcsLogUtil.collectFirstPack(log.getSelectedCommits(), VcsLogUtil.MAX_SELECTED_COMMITS);
  if (commits.isEmpty() || cherryPickManager.isCherryPickAlreadyStartedFor(commits)) {
    e.getPresentation().setEnabled(false);
    return;
  }

  final Map<VirtualFile, List<Hash>> groupedByRoot = groupByRoot(commits);
  VcsCherryPicker activeCherryPicker = getActiveCherryPicker(cherryPickers, groupedByRoot.keySet());
  String description = activeCherryPicker != null ? activeCherryPicker.getInfo(log, groupedByRoot) : SEVERAL_VCS_DESCRIPTION;
  e.getPresentation().setEnabled(description == null);
  e.getPresentation()
          .setText(activeCherryPicker == null ? concatActionNamesForAllAvailable(cherryPickers) : activeCherryPicker.getActionTitle());
  e.getPresentation().setDescription(description == null ? "" : description);
}
 

@Nonnull
private static Map<VirtualFile, List<Hash>> groupByRoot(@Nonnull List<CommitId> details) {
  Map<VirtualFile, List<Hash>> result = ContainerUtil.newHashMap();
  for (CommitId commit : details) {
    List<Hash> hashes = result.get(commit.getRoot());
    if (hashes == null) {
      hashes = ContainerUtil.newArrayList();
      result.put(commit.getRoot(), hashes);
    }
    hashes.add(commit.getHash());
  }
  return result;
}
 

@Test
public void testEqualsNull() throws Exception {
  Hash hash1 = HashImpl.build("adf");
  Assert.assertFalse(hash1.equals(null));
}
 

@Test
public void testEquals() throws Exception {
  Hash hash1 = HashImpl.build("adf");
  Hash hash2 = HashImpl.build("adf");
  Assert.assertTrue(hash1.equals(hash2));
}
 

@Test
public void testEqualsSelf() throws Exception {
  Hash hash1 = HashImpl.build("adf");
  Assert.assertTrue(hash1.equals(hash1));
}
 

@Test
public void testEqualsNone() throws Exception {
  Hash hash1 = HashImpl.build("");
  Hash hash2 = HashImpl.build("");
  Assert.assertTrue(hash1.equals(hash2));
}
 

public void runStringTest(String strHash) {
  Hash hash = HashImpl.build(strHash);
  Assert.assertEquals(strHash, hash.asString());
}
 

@Override
@Nonnull
public Hash getCommitHash() {
  return myCommitHash;
}
 

@Override
@Nonnull
public final List<Hash> getParents() {
  return myParents;
}
 

@Override
@Nonnull
public final Hash getId() {
  return myHash;
}
 

public TimedVcsCommitImpl(@Nonnull Hash hash, @Nonnull List<Hash> parents, long timeStamp) {
  myHash = hash;
  myParents = parents;
  myTime = timeStamp;
}
 

public VcsCommitMetadataImpl(@Nonnull Hash hash, @Nonnull List<Hash> parents, long commitTime, @Nonnull VirtualFile root,
                             @Nonnull String subject, @Nonnull VcsUser author, @Nonnull String message,
                             @Nonnull VcsUser committer, long authorTime) {
  super(hash, parents, commitTime, root, subject, author, committer, authorTime);
  myFullMessage = message.equals(getSubject()) ? getSubject() : message;
}
 

protected boolean isEnabled(@Nonnull Repo repository, @Nonnull Hash commit) {
  return true;
}
 

@Nonnull
public static Hash build(@Nonnull String inputStr) {
  byte[] data = buildData(inputStr);
  assert data.length > 0 : "Can not build hash for string " + inputStr;
  return new HashImpl(data);
}
 

protected boolean isVisible(@Nonnull final Project project, @Nonnull Repo repository, @Nonnull Hash hash) {
  return !getRepositoryManager(project).isExternal(repository);
}
 

public RepoStatusRemote(GitRemoteBranch remoteTrackingBranch, Hash parentHash) {
  this(remoteTrackingBranch, remoteTrackingBranch, parentHash);
}
 

private RevListCount(Status status, @Nullable Integer value, @Nullable Hash top) {
  this.value = value;
  this.status = status;
  this.top = top;
}
 

public static RevListCount success(int count, Hash top) {
  return new RevListCount(Status.SUCCESS, count, top);
}