private IEnumerable<string> ConvertToLocal(Change[] changes)
{
if (workspace == null)
{
return new string[0];
}
string[] serverItems = changes.Select(c => c.Item.ServerItem).ToArray();
var localizedServerItems = new List<string>();
foreach (string serverItem in serverItems)
{
string displayItem = null;
if (workspace != null)
{
displayItem = workspace.TryGetLocalItemForServerItem(serverItem);
}
if (string.IsNullOrEmpty(displayItem))
{
displayItem = serverItem;
}
localizedServerItems.Add(displayItem);
}
return localizedServerItems;
}
public async void VisualDiff(Change change)
{
if (!change.ChangeType.HasFlag(ChangeType.Edit))
return;
var others = await this.tfs.GetCheckinsAsync(change.Item.ServerItem);
Changeset previous = null;
if (others.Any())
{
previous = others
.SkipWhile(x => x.ChangesetId != change.Item.ChangesetId)
.Skip(1)
.FirstOrDefault();
}
if (previous == null)
{
return;
}
else
{
Change previousFile = change.ChangeType.HasFlag(ChangeType.Rename) && previous.Changes.Count() == 1
? previous.Changes.Single()
: previous.Changes.FirstOrDefault(s => s.Item.ServerItem == change.Item.ServerItem);
if (previousFile == null)
return;
this.VisualDiff(change.Item, previousFile.Item);
}
}
public void Update(Change change, string pathInGitRepo, GitIndexInfo index, IDictionary<string, GitObject> initialTree)
{
using (var tempFile = new TemporaryFile())
{
change.Item.DownloadFile(tempFile);
index.Update(GetMode(change, initialTree, pathInGitRepo),
UpdateDirectoryToMatchExtantCasing(pathInGitRepo, initialTree),
tempFile);
}
}
private void ApplyAdds(Change change, GitIndexInfo index, IDictionary<string, GitObject> initialTree)
{
var pathInGitRepo = Summary.Remote.GetPathInGitRepo(change.Item.ServerItem);
if (pathInGitRepo == null || Summary.Remote.ShouldSkip(pathInGitRepo))
return;
if (change.ChangeType != ChangeType.Delete)
{
Update(change, pathInGitRepo, index, initialTree);
}
}
private static FileChangeInfo CreateFileChange(Changeset changesetItem, Change changeItem)
{
var newInfo = new FileChangeInfo();
newInfo.ChangesetId = changesetItem.ChangesetId;
newInfo.ChangeType = changeItem.ChangeType;
newInfo.Member = changesetItem.Committer;
newInfo.ItemPath = changeItem.Item.ServerItem;
return newInfo;
}
public Change(tfs.Change change)
{
_change = change;
if (change.ChangeType.HasFlag(tfs.ChangeType.Rename) &&
change.Item.ItemType == tfs.ItemType.File &&
change.MergeSources != null &&
change.MergeSources.Any())
{
Rename = new MergeSource(_change.MergeSources.ElementAt(0));
}
}
public bool IsFilterPassed(Change change)
{
if (ChangeTypes != null
&& ChangeTypes.Count > 0
&& ChangeTypes.Any(c => c == change.ChangeType))
return true;
string fileExtension = Path.GetExtension(change.Item.ServerItem);
if (FileExtensions != null
&& FileExtensions.Count > 0
&& FileExtensions.Any(f => f == fileExtension))
return true;
return false;
}
internal static Change FromXml(Repository repository, XmlReader reader)
{
Change change = new Change();
string chgAttr = reader.GetAttribute("chg");
if (String.IsNullOrEmpty(chgAttr))
{
chgAttr = reader.GetAttribute("type");
}
change.changeType = (ChangeType) Enum.Parse(typeof(ChangeType), chgAttr.Replace(" ", ","), true);
reader.Read();
change.item = Item.FromXml(repository, reader);
return change;
}
private void Apply(Change change, GitIndexInfo index, IDictionary<string, GitObject> initialTree)
{
// If you make updates to a dir in TF, the changeset includes changes for all the children also,
// and git doesn't really care if you add or delete empty dirs.
if (change.Item.ItemType == ItemType.File)
{
var pathInGitRepo = Summary.Remote.GetPathInGitRepo(change.Item.ServerItem);
if (pathInGitRepo == null || Summary.Remote.ShouldSkip(pathInGitRepo))
return;
if (change.ChangeType.IncludesOneOf(ChangeType.Rename))
{
Rename(change, pathInGitRepo, index, initialTree);
}
else if (change.ChangeType.IncludesOneOf(ChangeType.Delete))
{
Delete(pathInGitRepo, index, initialTree);
}
else
{
Update(change, pathInGitRepo, index, initialTree);
}
}
}
private void ProcessFolderChange(Changeset changeset, Change change)
{
switch (change.ChangeType & TfsClientProvider.changeMask)
{
case ChangeType.Undelete:
// Undelete folder (really just an add)
UndeleteFolder(changeset, change);
break;
case ChangeType.Rename | ChangeType.Delete:
// "Delete, Rename" is possible and should be handled
DeleteFolder(changeset, change);
break;
case ChangeType.Rename:
RenameFolder(changeset, change);
break;
case ChangeType.Branch:
// Branch folder.
BranchFolder(changeset, change);
break;
case ChangeType.Add:
// Add folder.
AddFolder(changeset, change);
break;
case ChangeType.Delete:
// Delete folder.
DeleteFolder(changeset, change);
break;
case ChangeType.None:
break;
default:
throw new Exception(String.Format("Unmanaged folder change : {0}", change.ChangeType));
}
}
private void ProcessChange(Changeset changeset, Change change)
{
switch (change.Item.ItemType)
{
case ItemType.File:
// Process file change.
ProcessFileChange(changeset, change);
break;
case ItemType.Folder:
// Process folder change.
ProcessFolderChange(changeset, change);
break;
}
}
private void ProcessFileChange(Changeset changeset, Change change)
{
switch (change.ChangeType & TfsClientProvider.changeMask)
{
case ChangeType.Undelete:
case ChangeType.Undelete | ChangeType.Edit:
// Undelete file (really just an add)
UndeleteFile(changeset, change);
break;
case ChangeType.Rename | ChangeType.Delete:
// "Delete, Rename" is possible and should be handled
DeleteFile(changeset, change);
break;
case ChangeType.Rename | ChangeType.Edit:
//"Edit, Rename" is possible and should be handled
RenameFile(changeset, change);
EditFile(changeset, change);
break;
case ChangeType.Rename:
RenameFile(changeset, change);
break;
case ChangeType.Branch:
case ChangeType.Branch | ChangeType.Edit:
// Branch file.
BranchFile(changeset, change);
break;
case ChangeType.Add:
case ChangeType.Add | ChangeType.Edit:
// Add file.
AddFile(changeset, change);
break;
case ChangeType.Delete:
// Delete file.
DeleteFile(changeset, change);
break;
case ChangeType.Edit:
// Edit file.
EditFile(changeset, change);
break;
case ChangeType.None:
case 0://ChangeType.None different from 0 ?
break;
default:
throw new Exception(String.Format("Unmanaged file change : {0}, minus mask : {1} ", change.ChangeType, change.ChangeType & TfsClientProvider.changeMask));
}
}
private IChangeInfo Analyze(Change change)
{
if (this.IsLibFile(change.Item))
return null;
IChangeInfo info = null;
string url = change.Item.ServerItem;
Lazy<byte[]> fileContent = new Lazy<byte[]>(() => this.Download(change.Item));
if (BinaryHelper.IsProbablyBinary(url, fileContent))
return null;
if (change.ChangeType.HasFlag(ChangeType.Add)
|| change.ChangeType.HasFlag(ChangeType.Undelete))
{
info = new ChangeInfo
{
RemovedLines = 0,
AddedLines = this.CountLines(fileContent.Value),
};
}
else if (change.ChangeType.HasFlag(ChangeType.Delete)
&& !change.ChangeType.HasFlag(ChangeType.SourceRename)
&& !change.ChangeType.HasFlag(ChangeType.Rename))
{
info = new ChangeInfo
{
AddedLines = 0,
RemovedLines = this.CountLines(fileContent.Value),
};
}
else if (change.ChangeType.HasFlag(ChangeType.Edit)
|| change.ChangeType.HasFlag(ChangeType.Rollback))
{
var others = this.tfs.GetCheckins(url);
Changeset previous = null;
if (others.Any())
{
previous = others
.SkipWhile(x => x.ChangesetId != change.Item.ChangesetId)
.Skip(1)
.FirstOrDefault();
}
if (previous == null)
{
info = new ChangeInfo
{
RemovedLines = 0,
AddedLines = this.CountLines(fileContent.Value),
};
}
else
{
Change previousFile = change.ChangeType.HasFlag(ChangeType.Rename) && previous.Changes.Count() == 1
? previous.Changes.Single()
: previous.Changes.FirstOrDefault(s => s.Item.ServerItem == url);
if (previousFile == null)
return null;
info = this.DiffFiles(previousFile.Item, change.Item);
}
}
var local = info as ChangeInfo;
if (local != null)
{
local.FileCount = 1;
local.Name = change.Item.ServerItem;
}
return info;
}
private IEnumerable OrderChanges(Change[] changes)
{
ArrayList Undelete = new ArrayList();
ArrayList Edit = new ArrayList();
ArrayList Rename = new ArrayList();
ArrayList Branch = new ArrayList();
ArrayList Add = new ArrayList();
ArrayList Delete = new ArrayList();
/* Gestion of file swapping */
ArrayList EditRename_FS = new ArrayList();
ArrayList Add_FS = new ArrayList();
ArrayList Delete_FS = new ArrayList();
foreach (Change change in changes)
{
switch (change.ChangeType & TfsClientProvider.fullMask)
{
case ChangeType.SourceRename | ChangeType.Delete:
Delete_FS.Add(change);
break;
case ChangeType.SourceRename | ChangeType.Edit:
case ChangeType.SourceRename | ChangeType.Rename:
case ChangeType.SourceRename | ChangeType.Rename | ChangeType.Edit:
EditRename_FS.Add(change);
break;
case ChangeType.SourceRename | ChangeType.Add:
case ChangeType.SourceRename | ChangeType.Add | ChangeType.Edit:
Add_FS.Add(change);
break;
// fin de la gestion du file swapping
case ChangeType.Undelete:
case ChangeType.Undelete | ChangeType.Edit:
Undelete.Add(change);
break;
case ChangeType.Rename:
case ChangeType.Rename | ChangeType.Edit:
case ChangeType.Rename | ChangeType.Delete:
Rename.Add(change);
// no need to handle the edit here, rename will add the modified file to SVN
break;
case ChangeType.Branch:
case ChangeType.Branch | ChangeType.Edit:
Branch.Add(change);
break;
case ChangeType.Add:
case ChangeType.Add | ChangeType.Edit:
Add.Add(change);
break;
case ChangeType.Delete:
Delete.Add(change);
break;
case ChangeType.Edit:
Edit.Add(change);
break;
case ChangeType.None:
case 0://ChangeType.None different from 0 ?
break;
default:
throw new Exception(String.Format("Unmanaged change to order: {0}, minus mask : {1} ", change.ChangeType, change.ChangeType & TfsClientProvider.fullMask));
}
}
ArrayList l = new ArrayList();
// add the elements in the order of the following commands
l.AddRange(Rename);
l.AddRange(Undelete);
l.AddRange(Add);
l.AddRange(Delete);
l.AddRange(Edit);
l.AddRange(Branch);
l.AddRange(Delete_FS);
l.AddRange(EditRename_FS);
l.AddRange(Add_FS);
log.Info("Ordered Changes - Begin");
foreach (Change change in l)
{
log.Info(String.Format("Change - Item: {0} ChangeType: {1}", change.Item, change.ChangeType));
}
log.Info("Ordered Changes - End");
return l;
}
private void UndeleteFolder(Changeset changeset, Change change)
{
string itemPath = GetItemPath(change.Item);
Directory.CreateDirectory(itemPath);
if (this.FolderUndeleted != null)
this.FolderUndeleted(changeset.ChangesetId, itemPath, changeset.Committer, changeset.Comment, changeset.CreationDate);
}
bool VerifyChange(Item item, Change change)
{
return
item.ItemType == ItemType.File &&
!IsItemExcluded(item) &&
!_addedItems.Contains(item.ServerItem) &&
!change.ChangeType.HasFlag(ChangeType.Delete);
}
private void ProcessFolderChange(Changeset changeset, Change change)
{
// Undelete folder.
if ((change.ChangeType & ChangeType.Undelete) == ChangeType.Undelete)
UndeleteFolder(changeset, change);
// Rename folder.
else if ((change.ChangeType & ChangeType.Rename) == ChangeType.Rename)
RenameFolder(changeset, change);
// Branch folder.
else if ((change.ChangeType & ChangeType.Branch) == ChangeType.Branch)
BranchFolder(changeset, change);
// Add folder.
else if ((change.ChangeType & ChangeType.Add) == ChangeType.Add)
AddFolder(changeset, change);
// Delete folder.
else if ((change.ChangeType & ChangeType.Delete) == ChangeType.Delete)
DeleteFolder(changeset, change);
}
private Modification ConvertToModification(string userName, string comment, int changeNumber, string version, DateTime modifedTime, Change change)
{
Modification modification = new Modification();
modification.UserName = userName;
modification.Comment = comment;
modification.ChangeNumber = changeNumber;
modification.ModifiedTime = modifedTime;
modification.Version = version;
modification.Type = PendingChange.GetLocalizedStringForChangeType(change.ChangeType);
// Populate fields from change item
Item item = change.Item;
if (item.ItemType == ItemType.File)
{
// split into foldername and filename
int lastSlash = item.ServerItem.LastIndexOf('/');
modification.FileName = item.ServerItem.Substring(lastSlash + 1);
// patch to the following line submitted by Ralf Kretzschmar.
modification.FolderName = item.ServerItem.Substring(0, lastSlash);
}
else
{
// TODO - what should filename be if dir?? Empty string or null?
modification.FileName = string.Empty;
modification.FolderName = item.ServerItem;
}
return modification;
}
private void ProcessChange(Changeset changeset, Change change)
{
// Process file change.
if (change.Item.ItemType == ItemType.File)
ProcessFileChange(changeset, change);
// Process folder change.
else if (change.Item.ItemType == ItemType.Folder)
ProcessFolderChange(changeset, change);
}
private bool IsPartOfBranchDelete(Changeset changeset, Change change)
{
string[] excludedUrls = this.HasBranchDeletes(changeset);
if (excludedUrls == null)
return false;
return excludedUrls.Any(e => change.Item.ServerItem.StartsWith(e));
}
private IEnumerable OrderChanges(Change[] changes)
{
ArrayList Undelete = new ArrayList();
ArrayList Edit = new ArrayList();
ArrayList Rename = new ArrayList();
ArrayList Branch = new ArrayList();
ArrayList Add = new ArrayList();
ArrayList Delete = new ArrayList();
Console.WriteLine("unsorted: " + changes);
log.Info("unsorted: " + changes);
foreach (Change change in changes)
{
if ((change.ChangeType & ChangeType.Undelete) == ChangeType.Undelete)
Undelete.Add(change);
else if ((change.ChangeType & ChangeType.Rename) == ChangeType.Rename)
// no need to handle the edit here, rename will add the modified file to SVN
Rename.Add(change);
else if ((change.ChangeType & ChangeType.Branch) == ChangeType.Branch)
Branch.Add(change);
else if ((change.ChangeType & ChangeType.Add) == ChangeType.Add)
Add.Add(change);
else if ((change.ChangeType & ChangeType.Delete) == ChangeType.Delete)
Delete.Add(change);
else if ((change.ChangeType & ChangeType.Edit) == ChangeType.Edit)
Edit.Add(change);
}
ArrayList l = new ArrayList();
// add the elements in the order of the following commands
l.AddRange(Rename);
l.AddRange(Undelete);
l.AddRange(Add);
l.AddRange(Delete);
l.AddRange(Edit);
l.AddRange(Branch);
Console.WriteLine("sorted: " + l);
log.Info("sorted: " + l);
return l;
}
private string BuildComment( Changeset changeset, Change change )
{
return "[" + GetAssociatedWorkItems( changeset ) + "] " +
"(" + change.ChangeType + ") " +
changeset.Comment;
}
public IChangeInfo GetDiff(Changeset changeset, Change change, bool force)
{
if (change.Item.ItemType != ItemType.File
|| !HasOneFlag(change.ChangeType, ChangeType.Add, ChangeType.Delete, ChangeType.Edit, ChangeType.Undelete, ChangeType.Rollback))
return null;
if (this.IsPartOfBranchDelete(changeset, change))
return null;
return this.GetDiffCore(changeset, change, force);
}
private void RenameFolder(Changeset changeset, Change change)
{
string oldPath = GetItemPath(GetPreviousItem(change.Item));
string newPath = GetItemPath(change.Item);
if (this.FolderRenamed != null)
this.FolderRenamed(changeset.ChangesetId, oldPath, newPath, changeset.Committer, changeset.Comment, changeset.CreationDate);
}
private bool IsBranchDelete(Change change)
{
if (!change.ChangeType.HasFlag(ChangeType.Delete) || change.Item.ItemType != ItemType.Folder)
return false;
if (change.Item.IsBranch)
return true;
string cleanUrl = change.Item.ServerItem.TrimEnd('/');
if (cleanUrl.IndexOf("/RELEASE/") + "/RELEASE".Length == cleanUrl.LastIndexOf("/")
|| cleanUrl.IndexOf("/DEV/") + "/DEV".Length == cleanUrl.LastIndexOf("/")
|| cleanUrl.IndexOf("/DEVELOPMENT/") + "/DEVELOPMENT".Length == cleanUrl.LastIndexOf("/"))
return true;
return false;
}
private void UndeleteFile(Changeset changeset, Change change)
{
string itemPath = GetItemPath(change.Item);
DownloadItemFile(change, itemPath);
if (this.FileUndeleted != null)
this.FileUndeleted(changeset.ChangesetId, itemPath, changeset.Committer, changeset.Comment, changeset.CreationDate);
}
private static void SetChangeType(ChangedFileDto changedFile, Change change)
{
if (change.ChangeType.HasFlag(TFS.ChangeType.Add))
changedFile.ChangeType = Interface.ChangeType.Added;
else if (change.ChangeType.HasFlag(TFS.ChangeType.Delete))
changedFile.ChangeType = Interface.ChangeType.Deleted;
else
changedFile.ChangeType = Interface.ChangeType.Modified;
}
bool VerifyBackup(Item item, Change change)
{
return item.ItemType == ItemType.File &&
!IsItemExcluded(item) &&
!_backedupItems.Contains(item.ServerItem) &&
!change.ChangeType.HasFlag(ChangeType.Add);
}
private void DownloadItemFile(Change change, string targetPath)
{
try
{
//File.Delete is not needed (this is handled inside DownloadFile)
change.Item.DownloadFile(targetPath);
}
catch (Exception ex)
{
throw new Exception(String.Format("Error while downloading file '{0}' in Changeset #{1}.", targetPath, change.Item.ChangesetId), ex);
}
}
private void ProcessFileChange(Changeset changeset, Change change)
{
// Undelete file (really just an add)
if ((change.ChangeType & ChangeType.Undelete) == ChangeType.Undelete)
UndeleteFile(changeset, change);
// Rename file.
else if ((change.ChangeType & ChangeType.Rename) == ChangeType.Rename)
{
if ((change.ChangeType & ChangeType.Delete) == ChangeType.Delete)
{
// "Delete, Rename" is possible and should be handled
DeleteFile(changeset, change);
}
else
{
RenameFile(changeset, change);
//"Edit, Rename" is possible and should be handled
if ((change.ChangeType & ChangeType.Edit) == ChangeType.Edit)
EditFile(changeset, change);
}
}
// Branch file.
else if ((change.ChangeType & ChangeType.Branch) == ChangeType.Branch)
BranchFile(changeset, change);
// Add file.
else if ((change.ChangeType & ChangeType.Add) == ChangeType.Add)
AddFile(changeset, change);
// Delete file.
else if ((change.ChangeType & ChangeType.Delete) == ChangeType.Delete)
DeleteFile(changeset, change);
// Edit file.
else if ((change.ChangeType & ChangeType.Edit) == ChangeType.Edit)
EditFile(changeset, change);
}
private IChangeInfo GetDiffCore(Changeset changeset, Change change, bool force)
{
if (change.Item.ItemType != ItemType.File
|| !HasOneFlag(change.ChangeType, ChangeType.Add, ChangeType.Delete, ChangeType.Edit, ChangeType.Undelete, ChangeType.Rollback))
return null;
IChangeInfo info = null;
string key = changeset.ChangesetId.ToString() + change.Item.ItemId;
if (!force)
{
info = this.changesCache.GetById(key);
}
if (info == null)
{
info = this.Analyze(change);
}
if (info != null)
{
((ChangeInfo)info).Id = key;
this.changesCache.Save((ChangeInfo)info);
}
else
{
this.changesCache.Remove(key);
}
return info;
}
