@Override
@NotNull
public LogData readAllHashes(
@NotNull VirtualFile root, @NotNull final Consumer<TimedVcsCommit> commitConsumer)
throws VcsException {
if (!isRepositoryReady(root)) {
return LogDataImpl.empty();
}
List<String> parameters = new ArrayList<String>(GitHistoryUtils.LOG_ALL);
parameters.add("--date-order");
final GitBekParentFixer parentFixer = GitBekParentFixer.prepare(root, this);
Set<VcsUser> userRegistry = newHashSet();
Set<VcsRef> refs = newHashSet();
GitHistoryUtils.readCommits(
myProject,
root,
parameters,
new CollectConsumer<VcsUser>(userRegistry),
new CollectConsumer<VcsRef>(refs),
new Consumer<TimedVcsCommit>() {
@Override
public void consume(TimedVcsCommit commit) {
commitConsumer.consume(parentFixer.fixCommit(commit));
}
});
return new LogDataImpl(refs, userRegistry);
}
@NotNull
public static <CommitInfo> List<CommitInfo> getCommitRecords(
@NotNull Project project,
@Nullable HgCommandResult result,
@NotNull Function<String, CommitInfo> converter,
boolean silent) {
final List<CommitInfo> revisions = new LinkedList<CommitInfo>();
if (result == null) {
return revisions;
}
List<String> errors = result.getErrorLines();
if (errors != null && !errors.isEmpty()) {
if (result.getExitValue() != 0) {
if (silent) {
LOG.warn(errors.toString());
} else {
VcsNotifier.getInstance(project)
.notifyError(
HgVcsMessages.message("hg4idea.error.log.command.execution"), errors.toString());
}
return Collections.emptyList();
}
LOG.warn(errors.toString());
}
String output = result.getRawOutput();
List<String> changeSets = StringUtil.split(output, HgChangesetUtil.CHANGESET_SEPARATOR);
return ContainerUtil.mapNotNull(changeSets, converter);
}
private static Groups prepareGroups(
@NotNull VcsLogDataPack dataPack,
@Nullable Collection<VirtualFile> visibleRoots,
@Nullable List<List<String>> recentItems) {
Groups filteredGroups = new Groups();
Collection<VcsRef> allRefs = dataPack.getRefs().getBranches();
for (Map.Entry<VirtualFile, Set<VcsRef>> entry :
VcsLogUtil.groupRefsByRoot(allRefs).entrySet()) {
VirtualFile root = entry.getKey();
if (visibleRoots != null && !visibleRoots.contains(root)) continue;
Collection<VcsRef> refs = entry.getValue();
VcsLogProvider provider = dataPack.getLogProviders().get(root);
VcsLogRefManager refManager = provider.getReferenceManager();
List<RefGroup> refGroups = refManager.group(refs);
putActionsForReferences(refGroups, filteredGroups);
}
if (recentItems != null) {
for (List<String> recentItem : recentItems) {
if (recentItem.size() == 1) {
final String item = ContainerUtil.getFirstItem(recentItem);
if (filteredGroups.singletonGroups.contains(item)
|| ContainerUtil.find(
filteredGroups.expandedGroups.values(), strings -> strings.contains(item))
!= null) {
continue;
}
}
filteredGroups.recentGroups.add(recentItem);
}
}
return filteredGroups;
}
@NotNull
private DetailedLogData loadSomeCommitsOnTaggedBranches(
@NotNull VirtualFile root, int commitCount, @NotNull Collection<String> unmatchedTags)
throws VcsException {
List<String> params = new ArrayList<String>();
params.add("--max-count=" + commitCount);
params.addAll(unmatchedTags);
return GitHistoryUtils.loadMetadata(myProject, root, true, ArrayUtil.toStringArray(params));
}
@NotNull
public static List<String> prepareHashes(@NotNull List<String> hashes) {
List<String> hashArgs = new ArrayList<String>();
for (String hash : hashes) {
hashArgs.add("-r");
hashArgs.add(hash);
}
return hashArgs;
}
@NotNull
public static List<VcsCommitMetadata> loadMetadata(
@NotNull final Project project,
@NotNull final VirtualFile root,
int limit,
@NotNull List<String> parameters)
throws VcsException {
final VcsLogObjectsFactory factory = getObjectsFactoryWithDisposeCheck(project);
if (factory == null) {
return Collections.emptyList();
}
HgVcs hgvcs = HgVcs.getInstance(project);
assert hgvcs != null;
HgVersion version = hgvcs.getVersion();
List<String> templateList = HgBaseLogParser.constructDefaultTemplate(version);
templateList.add("{desc}");
String[] templates = ArrayUtil.toStringArray(templateList);
HgCommandResult result =
getLogResult(
project, root, version, limit, parameters, HgChangesetUtil.makeTemplate(templates));
HgBaseLogParser<VcsCommitMetadata> baseParser =
new HgBaseLogParser<VcsCommitMetadata>() {
@Override
protected VcsCommitMetadata convertDetails(
@NotNull String rev,
@NotNull String changeset,
@NotNull SmartList<HgRevisionNumber> parents,
@NotNull Date revisionDate,
@NotNull String author,
@NotNull String email,
@NotNull List<String> attributes) {
String message = parseAdditionalStringAttribute(attributes, MESSAGE_INDEX);
int subjectIndex = message.indexOf('\n');
String subject = subjectIndex == -1 ? message : message.substring(0, subjectIndex);
List<Hash> parentsHash = new SmartList<Hash>();
for (HgRevisionNumber parent : parents) {
parentsHash.add(factory.createHash(parent.getChangeset()));
}
return factory.createCommitMetadata(
factory.createHash(changeset),
parentsHash,
revisionDate.getTime(),
root,
subject,
author,
email,
message,
author,
email,
revisionDate.getTime());
}
};
return getCommitRecords(project, result, baseParser);
}
@NotNull
private DetailedLogData loadSomeCommitsOnTaggedBranches(
@NotNull VirtualFile root, int commitCount, @NotNull Collection<String> unmatchedTags)
throws VcsException {
StopWatch sw = StopWatch.start("loading commits on tagged branch in " + root.getName());
List<String> params = new ArrayList<String>();
params.add("--max-count=" + commitCount);
params.addAll(unmatchedTags);
sw.report();
return GitHistoryUtils.loadMetadata(myProject, root, true, ArrayUtil.toStringArray(params));
}
@NotNull
@Override
public List<TimedVcsCommit> readAllHashes(
@NotNull VirtualFile root, @NotNull Consumer<VcsUser> userRegistry) throws VcsException {
if (!isRepositoryReady(root)) {
return Collections.emptyList();
}
List<String> parameters = new ArrayList<String>(GitHistoryUtils.LOG_ALL);
parameters.add("--sparse");
return GitHistoryUtils.readCommits(myProject, root, userRegistry, parameters);
}
@NotNull
@Override
public List<? extends VcsFullCommitDetails> readFullDetails(
@NotNull VirtualFile root, @NotNull List<String> hashes) throws VcsException {
String noWalk =
GitVersionSpecialty.NO_WALK_UNSORTED.existsIn(myVcs.getVersion())
? "--no-walk=unsorted"
: "--no-walk";
List<String> params = new ArrayList<String>();
params.add(noWalk);
params.addAll(hashes);
return GitHistoryUtils.history(myProject, root, ArrayUtil.toStringArray(params));
}
@Nullable
private static HgCommandResult getLogResult(
@NotNull final Project project,
@NotNull final VirtualFile root,
@NotNull HgVersion version,
int limit,
@NotNull List<String> parameters,
@NotNull String template) {
HgFile originalHgFile = getOriginalHgFile(project, root);
HgLogCommand hgLogCommand = new HgLogCommand(project);
List<String> args = new ArrayList<String>(parameters);
hgLogCommand.setLogFile(false);
if (!version.isParentRevisionTemplateSupported()) {
args.add("--debug");
}
return hgLogCommand.execute(root, template, limit, originalHgFile, args);
}
@NotNull
private List<VcsCommitMetadata> loadSomeCommitsOnTaggedBranches(
@NotNull VirtualFile root, int commitCount, @NotNull List<VcsRef> unmatchedHeads)
throws VcsException {
List<String> params =
new ArrayList<String>(
ContainerUtil.map(
unmatchedHeads,
new Function<VcsRef, String>() {
@Override
public String fun(VcsRef ref) {
return ref.getCommitHash().asString();
}
}));
params.add("--max-count=" + commitCount);
return GitHistoryUtils.loadMetadata(myProject, root, ArrayUtil.toStringArray(params));
}
private static String printCommits(List<VcsCommitMetadata> commits) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < Math.min(commits.size(), 100); i++) {
GraphCommit<Hash> commit = commits.get(i);
sb.append(
String.format(
"%s -> %s\n",
commit.getId().toShortString(),
StringUtil.join(
commit.getParents(),
new Function<Hash, String>() {
@Override
public String fun(Hash hash) {
return hash.toShortString();
}
},
", ")));
}
return sb.toString();
}
@NotNull
@Override
public List<? extends VcsCommitMetadata> readFirstBlock(
@NotNull VirtualFile root, @NotNull Requirements requirements) throws VcsException {
if (!isRepositoryReady(root)) {
return Collections.emptyList();
}
int commitCount = requirements.getCommitCount();
if (requirements.isOrdered()) {
commitCount *=
2; // need to query more to sort them manually; this doesn't affect performance: it is
// equal for -1000 and -2000
}
String[] params =
new String[] {"HEAD", "--branches", "--remotes", "--max-count=" + commitCount};
// NB: not specifying --tags, because it introduces great slowdown if there are many tags,
// but makes sense only if there are heads without branch or HEAD labels (rare case). Such cases
// are partially handles below.
List<VcsCommitMetadata> firstBlock = GitHistoryUtils.loadMetadata(myProject, root, params);
if (requirements instanceof VcsLogProviderRequirementsEx) {
VcsLogProviderRequirementsEx rex = (VcsLogProviderRequirementsEx) requirements;
// on refresh: get new tags, which point to commits not from the first block; then get
// history, walking down just from these tags
// on init: just ignore such tagged-only branches. The price for speed-up.
if (!rex.isOrdered()) {
Collection<VcsRef> newTags = getNewTags(rex.getCurrentRefs(), rex.getPreviousRefs());
if (!newTags.isEmpty()) {
final Set<Hash> firstBlockHashes =
ContainerUtil.map2Set(
firstBlock,
new Function<VcsCommitMetadata, Hash>() {
@Override
public Hash fun(VcsCommitMetadata metadata) {
return metadata.getHash();
}
});
List<VcsRef> unmatchedHeads = getUnmatchedHeads(firstBlockHashes, newTags);
if (!unmatchedHeads.isEmpty()) {
List<VcsCommitMetadata> detailsFromTaggedBranches =
loadSomeCommitsOnTaggedBranches(root, commitCount, unmatchedHeads);
Collection<VcsCommitMetadata> unmatchedCommits =
getUnmatchedCommits(firstBlockHashes, detailsFromTaggedBranches);
firstBlock.addAll(unmatchedCommits);
}
}
}
}
if (requirements.isOrdered()) {
firstBlock = VcsLogSorter.sortByDateTopoOrder(firstBlock);
firstBlock =
new ArrayList<VcsCommitMetadata>(
firstBlock.subList(0, Math.min(firstBlock.size(), requirements.getCommitCount())));
}
return firstBlock;
}
@NotNull
public static Collection<String> getDescendingHeadsOfBranches(
@NotNull Project project, @NotNull VirtualFile root, @NotNull Hash hash) throws VcsException {
// hg log -r "descendants(659db54c1b6865c97c4497fa867194bcd759ca76) and head()" --template
// "{branch}{bookmarks}"
Set<String> branchHeads = new HashSet<String>();
List<String> params = new ArrayList<String>();
params.add("-r");
params.add("descendants(" + hash.asString() + ") and head()");
HgLogCommand hgLogCommand = new HgLogCommand(project);
hgLogCommand.setLogFile(false);
String template = HgChangesetUtil.makeTemplate("{branch}", "{bookmarks}");
HgCommandResult logResult = hgLogCommand.execute(root, template, -1, null, params);
if (logResult == null || logResult.getExitValue() != 0) {
throw new VcsException("Couldn't get commit details: log command execution error.");
}
String output = logResult.getRawOutput();
List<String> changeSets = StringUtil.split(output, HgChangesetUtil.CHANGESET_SEPARATOR);
for (String line : changeSets) {
List<String> attributes = StringUtil.split(line, HgChangesetUtil.ITEM_SEPARATOR);
branchHeads.addAll(attributes);
}
return branchHeads;
}
@NotNull
@Override
public List<TimedVcsCommit> getCommitsMatchingFilter(
@NotNull final VirtualFile root,
@NotNull VcsLogFilterCollection filterCollection,
int maxCount)
throws VcsException {
if (!isRepositoryReady(root)) {
return Collections.emptyList();
}
List<String> filterParameters = ContainerUtil.newArrayList();
if (filterCollection.getBranchFilter() != null
&& !filterCollection.getBranchFilter().getBranchNames().isEmpty()) {
GitRepository repository = getRepository(root);
assert repository != null
: "repository is null for root " + root + " but was previously reported as 'ready'";
boolean atLeastOneBranchExists = false;
for (String branchName : filterCollection.getBranchFilter().getBranchNames()) {
if (branchName.equals("HEAD")
|| repository.getBranches().findBranchByName(branchName) != null) {
filterParameters.add(branchName);
atLeastOneBranchExists = true;
}
}
if (!atLeastOneBranchExists) { // no such branches in this repository => filter matches
// nothing
return Collections.emptyList();
}
} else {
filterParameters.addAll(GitHistoryUtils.LOG_ALL);
}
if (filterCollection.getUserFilter() != null) {
String authorFilter =
StringUtil.join(
ContainerUtil.map(
filterCollection.getUserFilter().getUserNames(root), UserNameRegex.INSTANCE),
"|");
filterParameters.add(prepareParameter("author", StringUtil.escapeBackSlashes(authorFilter)));
filterParameters.add(
"--extended-regexp"); // extended regexp required for correctly filtering user names
}
if (filterCollection.getDateFilter() != null) {
// assuming there is only one date filter, until filter expressions are defined
VcsLogDateFilter filter = filterCollection.getDateFilter();
if (filter.getAfter() != null) {
filterParameters.add(prepareParameter("after", filter.getAfter().toString()));
}
if (filter.getBefore() != null) {
filterParameters.add(prepareParameter("before", filter.getBefore().toString()));
}
}
if (filterCollection.getTextFilter() != null) {
String textFilter = filterCollection.getTextFilter().getText();
filterParameters.add(prepareParameter("grep", StringUtil.escapeChars(textFilter, '[', ']')));
}
filterParameters.add(
"--regexp-ignore-case"); // affects case sensitivity of any filter (except file filter)
if (maxCount > 0) {
filterParameters.add(prepareParameter("max-count", String.valueOf(maxCount)));
}
// note: structure filter must be the last parameter, because it uses "--" which separates
// parameters from paths
if (filterCollection.getStructureFilter() != null) {
Collection<VirtualFile> files = filterCollection.getStructureFilter().getFiles();
if (!files.isEmpty()) {
filterParameters.add("--full-history");
filterParameters.add("--simplify-merges");
filterParameters.add("--");
for (VirtualFile file : files) {
filterParameters.add(file.getPath());
}
}
}
List<TimedVcsCommit> commits = ContainerUtil.newArrayList();
GitHistoryUtils.readCommits(
myProject,
root,
filterParameters,
EmptyConsumer.<VcsUser>getInstance(),
EmptyConsumer.<VcsRef>getInstance(),
new CollectConsumer<TimedVcsCommit>(commits));
return commits;
}
@NotNull
@Override
public DetailedLogData readFirstBlock(
@NotNull VirtualFile root, @NotNull Requirements requirements) throws VcsException {
if (!isRepositoryReady(root)) {
return LogDataImpl.empty();
}
GitRepository repository =
ObjectUtils.assertNotNull(myRepositoryManager.getRepositoryForRoot(root));
// need to query more to sort them manually; this doesn't affect performance: it is equal for
// -1000 and -2000
int commitCount = requirements.getCommitCount() * 2;
String[] params =
new String[] {"HEAD", "--branches", "--remotes", "--max-count=" + commitCount};
// NB: not specifying --tags, because it introduces great slowdown if there are many tags,
// but makes sense only if there are heads without branch or HEAD labels (rare case). Such cases
// are partially handled below.
boolean refresh =
requirements instanceof VcsLogProviderRequirementsEx
&& ((VcsLogProviderRequirementsEx) requirements).isRefresh();
DetailedLogData data = GitHistoryUtils.loadMetadata(myProject, root, true, params);
Set<VcsRef> safeRefs = data.getRefs();
Set<VcsRef> allRefs = new OpenTHashSet<VcsRef>(safeRefs, DONT_CONSIDER_SHA);
Set<VcsRef> branches = readBranches(repository);
addNewElements(allRefs, branches);
Collection<VcsCommitMetadata> allDetails;
Set<String> currentTagNames = null;
DetailedLogData commitsFromTags = null;
if (!refresh) {
allDetails = data.getCommits();
} else {
// on refresh: get new tags, which point to commits not from the first block; then get
// history, walking down just from these tags
// on init: just ignore such tagged-only branches. The price for speed-up.
VcsLogProviderRequirementsEx rex = (VcsLogProviderRequirementsEx) requirements;
currentTagNames = readCurrentTagNames(root);
addOldStillExistingTags(allRefs, currentTagNames, rex.getPreviousRefs());
allDetails = newHashSet(data.getCommits());
Set<String> previousTags =
newHashSet(ContainerUtil.mapNotNull(rex.getPreviousRefs(), GET_TAG_NAME));
Set<String> safeTags = newHashSet(ContainerUtil.mapNotNull(safeRefs, GET_TAG_NAME));
Set<String> newUnmatchedTags = remove(currentTagNames, previousTags, safeTags);
if (!newUnmatchedTags.isEmpty()) {
commitsFromTags = loadSomeCommitsOnTaggedBranches(root, commitCount, newUnmatchedTags);
addNewElements(allDetails, commitsFromTags.getCommits());
addNewElements(allRefs, commitsFromTags.getRefs());
}
}
StopWatch sw = StopWatch.start("sorting commits in " + root.getName());
List<VcsCommitMetadata> sortedCommits = VcsLogSorter.sortByDateTopoOrder(allDetails);
sortedCommits =
sortedCommits.subList(0, Math.min(sortedCommits.size(), requirements.getCommitCount()));
sw.report();
if (LOG.isDebugEnabled()) {
validateDataAndReportError(
root, allRefs, sortedCommits, data, branches, currentTagNames, commitsFromTags);
}
return new LogDataImpl(allRefs, sortedCommits);
}
public static List<? extends VcsFullCommitDetails> createFullCommitsFromResult(
@NotNull Project project,
@NotNull VirtualFile root,
@Nullable HgCommandResult result,
@NotNull HgVersion version,
boolean silent) {
final VcsLogObjectsFactory factory = getObjectsFactoryWithDisposeCheck(project);
if (factory == null) {
return Collections.emptyList();
}
List<HgFileRevision> hgRevisions =
getCommitRecords(
project,
result,
new HgFileRevisionLogParser(project, getOriginalHgFile(project, root), version),
silent);
List<VcsFullCommitDetails> vcsFullCommitDetailsList = new ArrayList<VcsFullCommitDetails>();
for (HgFileRevision revision : hgRevisions) {
HgRevisionNumber vcsRevisionNumber = revision.getRevisionNumber();
List<HgRevisionNumber> parents = vcsRevisionNumber.getParents();
HgRevisionNumber firstParent =
parents.isEmpty() ? null : parents.get(0); // can have no parents if it is a root
List<Hash> parentsHash = new SmartList<Hash>();
for (HgRevisionNumber parent : parents) {
parentsHash.add(factory.createHash(parent.getChangeset()));
}
final Collection<Change> changes = new ArrayList<Change>();
for (String file : revision.getModifiedFiles()) {
changes.add(
createChange(
project, root, file, firstParent, file, vcsRevisionNumber, FileStatus.MODIFIED));
}
for (String file : revision.getAddedFiles()) {
changes.add(
createChange(project, root, null, null, file, vcsRevisionNumber, FileStatus.ADDED));
}
for (String file : revision.getDeletedFiles()) {
changes.add(
createChange(
project, root, file, firstParent, null, vcsRevisionNumber, FileStatus.DELETED));
}
for (Map.Entry<String, String> copiedFile : revision.getCopiedFiles().entrySet()) {
changes.add(
createChange(
project,
root,
copiedFile.getKey(),
firstParent,
copiedFile.getValue(),
vcsRevisionNumber,
FileStatus.ADDED));
}
vcsFullCommitDetailsList.add(
factory.createFullDetails(
factory.createHash(vcsRevisionNumber.getChangeset()),
parentsHash,
revision.getRevisionDate().getTime(),
root,
vcsRevisionNumber.getSubject(),
vcsRevisionNumber.getAuthor(),
vcsRevisionNumber.getEmail(),
vcsRevisionNumber.getCommitMessage(),
vcsRevisionNumber.getAuthor(),
vcsRevisionNumber.getEmail(),
revision.getRevisionDate().getTime(),
new ThrowableComputable<Collection<Change>, Exception>() {
@Override
public Collection<Change> compute() throws Exception {
return changes;
}
}));
}
return vcsFullCommitDetailsList;
}
