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; }