public async Task <Dictionary <string, Commit> > Run(IEnumerable <string> commitsToRewrite)
{
_progress = new Progress();
commitMap = commitsToRewrite
.ToDictionary(sha => sha, sha => Task.Factory.StartNew(() =>
{
var x = new CommitMetadata(repo.Lookup <Commit>(sha));
System.Threading.Interlocked.Increment(ref _progress.Loaded);
return(x);
}, new System.Threading.CancellationToken(), TaskCreationOptions.LongRunning, ioScheduler));
var rewriterTasks = commitMap.Keys
.ToDictionary(sha => sha, sha => new Task <Task <Commit> >(() => rewrite(sha)));
rewrittenMap = rewriterTasks
.ToDictionary(e => e.Key, e => e.Value.Unwrap().ContinueWith(t =>
{
System.Threading.Interlocked.Increment(ref _progress.Done);
return(t.Result);
}));
// Now start our tasks
Parallel.ForEach(rewriterTasks.Values, t => t.Start());
await Task.WhenAll(rewrittenMap.Values);
return(rewrittenMap
.ToDictionary(e => e.Key, e => e.Value.Result));
}
private async Task <IEnumerable <Commit> > GetOriginalParents(CommitMetadata commitMeta)
{
var parents = new List <Commit>();
if (commitMeta.Original == null)
{
return(parents);
}
foreach (var parent in commitMeta.Original.Parents)
{
if (commitMap.ContainsKey(parent.Sha))
{
var rewrittenParent = await Map(parent.Sha).ConfigureAwait(false);
if (rewrittenParent != null)
{
parents.AddRange(rewrittenParent);
}
}
else
{
// Not being rewritten
parents.Add(parent);
}
}
return(parents);
}
public bool pruneEmptyFilter(CommitMetadata commit, Tree savedTree)
{
// Re-process merges to eliminate branches that don't contribute anything to the tree
if (commit.Parents.Count > 1 && pruneMergesAggressive)
{
var treeSameTo = commit.Parents.Where(p => savedTree.Equals(p.Tree)).FirstOrDefault();
if (treeSameTo != null)
{
// eliminate the parents that are not treesame as they contribute nothing
commit.Parents = commit.Parents.Where(p => p.Tree.Equals(treeSameTo.Tree)).Distinct().ToList();
// If it's demoted from a merge, it's a pointless commit now
// as it's treesame to its only parent. So dump out early and drop it
if (commit.Parents.Count == 1)
{
return(false);
}
}
}
if (commit.Parents.Count == 2 && pruneMerges)
{
// Heuristic to quickly eliminate the common case of a triangle
var p1 = commit.Parents[0];
var p2 = commit.Parents[1];
if (p2.Parents.Contains(p1))
{
// p1 is redundant as it's reachable from p2
commit.Parents.Remove(p1);
}
else if (p1.Parents.Contains(p2))
{
// p2 is redundant since reachable from p1
commit.Parents.Remove(p2);
}
}
if (commit.Parents.Count > 1 && pruneMerges)
{
commit.Parents = GetIndependent(commit.Parents.Distinct());
}
if (commit.Parents.Count == 0)
{
return(savedTree.Count != 0); // Don't include null trees if we're a root
}
if (commit.Parents.Count == 1 && savedTree.Equals(commit.Parents[0].Tree))
{
return(false); // Skip unchanged
}
return(true);
}
private async Task <bool> runParentFilters(CommitMetadata meta)
{
foreach (var f in filters.ParentFilters)
{
if (await f.FilterParents(meta, parentCtx).ConfigureAwait(false) == false)
{
return(false); // drop!
}
}
return(true);
}
private bool runMetadataFilters(CommitMetadata meta)
{
foreach (var f in filters.MetadataFilters)
{
if (f.FilterCommit(meta, metaCtx) == false)
{
return(false); // Drop
}
}
return(true);
}
