private IEnumerable <string> GetFilesTouchedOnDifferentParentBranches(
ICommitMappingExpression expression, Log log)
{
List <string> filesTouchedOnDifferentBranches = new List <string>();
var parentBranchMasks = expression.SelectionDSL()
.Commits().RevisionIsIn(log.ParentRevisions)
.Branches().OfCommits()
.Select(b => b.Mask).ToArray();
var commonParentMask = BranchMask.And(parentBranchMasks);
if (log.ParentRevisions.Count() == 2) // merge of two branches -> simple case
{
var firstBranchMask = BranchMask.Xor(parentBranchMasks[0], commonParentMask);
var secondBranchMask = BranchMask.Xor(parentBranchMasks[1], commonParentMask);
filesTouchedOnDifferentBranches.AddRange(
GetFilesTouchedOnDifferentBranches(expression, firstBranchMask, secondBranchMask));
}
else
{
var fullParentMask = BranchMask.Or(parentBranchMasks);
foreach (var parentBranchMask in parentBranchMasks)
{
var currentBranchMask = BranchMask.Xor(parentBranchMask, commonParentMask);
var otherBranchesMask = BranchMask.Xor(currentBranchMask, BranchMask.Xor(commonParentMask, fullParentMask));
filesTouchedOnDifferentBranches.AddRange(
GetFilesTouchedOnDifferentBranches(expression, currentBranchMask, otherBranchesMask));
}
}
return(filesTouchedOnDifferentBranches);
}
private Branch NewBranch(BranchMask mask, bool createMask, bool combineMask)
{
var newBranch = new Branch()
{
Mask = mask
};
// create a new branch mask
if (createMask)
{
var branchWithMaxMask = GetReadOnly <Branch>()
.OrderByDescending(x => x.Mask.Data.Length + x.Mask.Offset)
.FirstOrDefault();
var newMask = new BranchMask()
{
Data = string.Format("{0}1",
branchWithMaxMask == null ? string.Empty
: new String('0', branchWithMaxMask.Mask.Data.Length + branchWithMaxMask.Mask.Offset)),
Offset = 0
};
// combine masks for subbranch
if (combineMask)
{
newBranch.Mask = BranchMask.Or(newBranch.Mask, newMask);
}
else
{
newBranch.Mask = newMask;
}
}
return(newBranch);
}
public static CommitSelectionExpression OnBranchForward(
this CommitSelectionExpression parentExp, BranchMask mask)
{
return(parentExp.Reselect(s =>
from c in s
join br in parentExp.Queryable <Branch>() on c.BranchId equals br.Id
let branch_bit_pos = mask.Data.Length + mask.Offset - 1 - br.Mask.Offset
where
(branch_bit_pos < 0)
||
(branch_bit_pos < br.Mask.Data.Length && br.Mask.Data.Substring(branch_bit_pos, 1) == "1")
select c));
}
public override IEnumerable <IBranchMappingExpression> Map(ICommitMappingExpression expression)
{
var log = vcsData.Log(expression.CurrentEntity <Commit>().Revision);
if (log.IsOrphan)
{
return(SingleExpression(expression
.OnFreshBranch()));
}
else // one or more parent revisions
{
var parentBranches =
(from c in expression.GetReadOnly <Commit>()
join b in expression.GetReadOnly <Branch>() on c.BranchId equals b.Id
where log.ParentRevisions.Contains(c.Revision)
select b).ToArray();
var parentChildren = log.ParentRevisions
.SelectMany(pr => vcsData.Log(pr).ChildRevisions)
.Distinct().Count();
if (parentBranches.Length == 1) // single-parent revision
{
if (parentChildren == 1)
{
return(SingleExpression(expression
.OnBranch(parentBranches[0].Mask)));
}
else
{
return(SingleExpression(expression
.OnSubBranch(parentBranches[0].Mask)));
}
}
else // multi-parent revision (merge)
{
var combinedMask = BranchMask.Or(
parentBranches.Select(x => x.Mask).ToArray());
if (parentChildren == 1)
{
return(SingleExpression(expression
.OnBranch(combinedMask)));
}
else
{
return(SingleExpression(expression
.OnSubBranch(combinedMask)));
}
}
}
}
private IEnumerable <string> GetFilesTouchedOnParentBranches(
ICommitMappingExpression expression, Log log)
{
var parentBranchMasks = expression.SelectionDSL()
.Commits().RevisionIsIn(log.ParentRevisions)
.Branches().OfCommits()
.Select(b => b.Mask).ToArray();
var andMask = BranchMask.And(parentBranchMasks);
var orMask = BranchMask.Or(parentBranchMasks);
var branchesMask = BranchMask.Xor(andMask, orMask);
return(expression.SelectionDSL()
.Commits().OnBranchBack(branchesMask)
.Files().TouchedInAndStillExistAfterCommits()
.Select(x => x.Path).ToArray());
}
private IEnumerable <string> GetFilesTouchedOnDifferentBranches(
ICommitMappingExpression expression,
BranchMask singleBranchMask,
BranchMask otherBranchesMask)
{
var filesTouchedOnBranch = expression.SelectionDSL()
.Commits().OnBranchBack(singleBranchMask)
.Files().TouchedInAndStillExistAfterCommits().Select(x => x.Path);
var filesTouchedOnOtherBranches = expression.SelectionDSL()
.Commits().OnBranchBack(otherBranchesMask)
.Files().TouchedInAndStillExistAfterCommits().Select(x => x.Path);
foreach (var file in filesTouchedOnBranch.Intersect(filesTouchedOnOtherBranches))
{
yield return(file);
}
}
public BranchMappingExpression(
IRepositoryMappingExpression parentExp,
BranchMask mask,
bool subBranch)
: base(parentExp)
{
entity = Get <Branch>()
.SingleOrDefault(b => b.Mask.Data == mask.Data && b.Mask.Offset == mask.Offset);
if (entity == null)
{
entity = NewBranch(mask, subBranch, subBranch);
Add(entity);
}
else
{
if (subBranch)
{
entity = NewBranch(mask, true, true);
Add(entity);
}
}
entity.Commits.Add(CurrentEntity <Commit>());
}
/// <summary>
/// Create a new sub-branch based on parent branch mask and offset.
/// </summary>
public static BranchMappingExpression OnSubBranch(
this ICommitMappingExpression exp, BranchMask parentMask)
{
return(new BranchMappingExpression(exp, parentMask, true));
}
/// <summary>
/// Create a new branch or use the existent one with specified mask and offset.
/// </summary>
public static BranchMappingExpression OnBranch(
this ICommitMappingExpression exp, BranchMask mask)
{
return(new BranchMappingExpression(exp, mask, false));
}
