} // End Function ReadFile public static string GetDiff(Repository repo, DiffEntry entry) { string strDiff = null; using (System.IO.MemoryStream ms = new System.IO.MemoryStream()) { DiffFormatter diffFormatter = new DiffFormatter(ms); diffFormatter.SetRepository(repo); diffFormatter.Format(diffFormatter.ToFileHeader(entry)); ms.Position = 0; using (System.IO.StreamReader sr = new System.IO.StreamReader(ms)) { strDiff = sr.ReadToEnd(); } } return strDiff; } // End Function GetDiff
/// <exception cref="System.IO.IOException"></exception> private DiffEntry FindRename(RevCommit parent, RevCommit commit, PathFilter path) { if (renameDetector == null) { return(null); } treeWalk.Filter = TreeFilter.ANY_DIFF; treeWalk.Reset(parent.Tree, commit.Tree); renameDetector.Reset(); renameDetector.AddAll(DiffEntry.Scan(treeWalk)); foreach (DiffEntry ent in renameDetector.Compute()) { if (IsRename(ent) && ent.GetNewPath().Equals(path.GetPath())) { return(ent); } } return(null); }
public virtual void TestNoOutputStreamSet() { FilePath file = WriteTrashFile("test.txt", "a"); NUnit.Framework.Assert.IsTrue(file.SetLastModified(file.LastModified() - 5000)); Git git = new Git(db); git.Add().AddFilepattern(".").Call(); Write(file, "b"); IList <DiffEntry> diffs = git.Diff().Call(); NUnit.Framework.Assert.IsNotNull(diffs); NUnit.Framework.Assert.AreEqual(1, diffs.Count); DiffEntry diff = diffs[0]; NUnit.Framework.Assert.AreEqual(DiffEntry.ChangeType.MODIFY, diff.GetChangeType() ); NUnit.Framework.Assert.AreEqual("test.txt", diff.GetOldPath()); NUnit.Framework.Assert.AreEqual("test.txt", diff.GetNewPath()); }
public void Execute(TaskExecutionMode mode) { if (this.CancellationToken.IsCancellationRequested) { throw new OperationCanceledException(this.CancellationToken); } try { SchemaCompareEndpoint sourceEndpoint = CreateSchemaCompareEndpoint(this.Parameters.SourceEndpointInfo, this.SourceConnectionString); SchemaCompareEndpoint targetEndpoint = CreateSchemaCompareEndpoint(this.Parameters.TargetEndpointInfo, this.TargetConnectionString); SchemaComparison comparison = new SchemaComparison(sourceEndpoint, targetEndpoint); if (this.Parameters.DeploymentOptions != null) { comparison.Options = this.CreateSchemaCompareOptions(this.Parameters.DeploymentOptions); } this.ComparisonResult = comparison.Compare(); // try one more time if it didn't work the first time if (!this.ComparisonResult.IsValid) { this.ComparisonResult = comparison.Compare(); } this.Differences = new List <DiffEntry>(); foreach (SchemaDifference difference in this.ComparisonResult.Differences) { DiffEntry diffEntry = CreateDiffEntry(difference, null); this.Differences.Add(diffEntry); } } catch (Exception e) { ErrorMessage = e.Message; Logger.Write(TraceEventType.Error, string.Format("Schema compare operation {0} failed with exception {1}", this.OperationId, e.Message)); throw; } }
public void LoadDiffs(string fileName) { _diffs.Clear(); using (var zip = ZipFile.Read(fileName)) { foreach (var entry in zip.Entries) { using (var stream = new MemoryStream()) { entry.Extract(stream); stream.Seek(0, SeekOrigin.Begin); using (var reader = new StreamReader(stream)) { var diff = new DiffEntry(reader.ReadLine(), reader.ReadToEnd()); _diffs.Add(diff); } } } } }
private static string Path(DiffEntry difference) { switch (difference.GetChangeType()) { case DiffEntry.ChangeType.ADD: return(difference.GetNewPath()); case DiffEntry.ChangeType.COPY: return(string.Format("{0} -> {1}", difference.GetOldPath(), difference.GetNewPath())); case DiffEntry.ChangeType.DELETE: return(difference.GetOldPath()); case DiffEntry.ChangeType.MODIFY: return(difference.GetOldPath()); case DiffEntry.ChangeType.RENAME: return(string.Format("{0} -> {1}", difference.GetOldPath(), difference.GetNewPath())); default: return(difference.ToString()); } }
private bool IsEqual(SchemaDifference difference, DiffEntry diffEntry) { bool result = true; // Create a diff entry from difference and check if it matches the diff entry passed DiffEntry entryFromDifference = SchemaCompareUtils.CreateDiffEntry(difference, null); System.Reflection.PropertyInfo[] properties = diffEntry.GetType().GetProperties(); foreach (var prop in properties) { // Don't need to check if included is the same when verifying if the difference is equal if (prop.Name != "Included") { if (!((prop.GetValue(diffEntry) == null && prop.GetValue(entryFromDifference) == null) || prop.GetValue(diffEntry).SafeToString().Equals(prop.GetValue(entryFromDifference).SafeToString()))) { return(false); } } } return(result); }
public IEnumerable <FileDiff> GetFileDiffs(string newHash, string oldHash) { NGit.Repository repo = this.git.GetRepository(); ObjectId newCommit = repo.Resolve(newHash + "^{tree}"); ObjectId oldCommit = repo.Resolve(oldHash + "^{tree}"); var walk = new TreeWalk(repo) { Recursive = true }; walk.AddTree(oldCommit); walk.AddTree(newCommit); IEnumerable <DiffEntry> entries = DiffEntry.Scan(walk); var diffs = entries.Where(diff => diff.GetNewId().Name != diff.GetOldId().Name); return(from diffEntry in diffs let diffType = ToDiffType(diffEntry.GetChangeType()) let path = diffType == DiffType.Delete ? diffEntry.GetOldPath() : diffEntry.GetNewPath() select new FileDiff(path, diffType)); }
/// <exception cref="NGit.Errors.MissingObjectException"></exception> /// <exception cref="NGit.Errors.IncorrectObjectTypeException"></exception> /// <exception cref="NGit.Errors.CorruptObjectException"></exception> /// <exception cref="System.IO.IOException"></exception> private void UpdateFollowFilter(ObjectId[] trees) { TreeWalk tw = pathFilter; FollowFilter oldFilter = (FollowFilter)tw.Filter; tw.Filter = TreeFilter.ANY_DIFF; tw.Reset(trees); IList <DiffEntry> files = DiffEntry.Scan(tw); RenameDetector rd = new RenameDetector(repository); rd.AddAll(files); files = rd.Compute(); TreeFilter newFilter = oldFilter; foreach (DiffEntry ent in files) { if (IsRename(ent) && ent.GetNewPath().Equals(oldFilter.GetPath())) { newFilter = FollowFilter.Create(ent.GetOldPath()); break; } } tw.Filter = newFilter; }
public override void Renamed(DiffEntry diff) { diffs.AddItem(diff); }
private void ValidateSchemaCompareScriptGenerationWithExcludeIncludeResults(SchemaCompareOperation schemaCompareOperation, SchemaCompareGenerateScriptParams generateScriptParams) { schemaCompareOperation.Execute(TaskExecutionMode.Execute); Assert.True(schemaCompareOperation.ComparisonResult.IsValid); Assert.False(schemaCompareOperation.ComparisonResult.IsEqual); Assert.NotNull(schemaCompareOperation.ComparisonResult.Differences); SchemaCompareGenerateScriptOperation generateScriptOperation = new SchemaCompareGenerateScriptOperation(generateScriptParams, schemaCompareOperation.ComparisonResult); generateScriptOperation.Execute(TaskExecutionMode.Execute); string initialScript = File.ReadAllText(generateScriptParams.ScriptFilePath); // create Diff Entry from on Difference DiffEntry diff = SchemaCompareOperation.CreateDiffEntry(schemaCompareOperation.ComparisonResult.Differences.First(), null); int initial = schemaCompareOperation.ComparisonResult.Differences.Count(); SchemaCompareNodeParams schemaCompareExcludeNodeParams = new SchemaCompareNodeParams() { OperationId = schemaCompareOperation.OperationId, DiffEntry = diff, IncludeRequest = false, TaskExecutionMode = TaskExecutionMode.Execute }; SchemaCompareIncludeExcludeNodeOperation nodeExcludeOperation = new SchemaCompareIncludeExcludeNodeOperation(schemaCompareExcludeNodeParams, schemaCompareOperation.ComparisonResult); nodeExcludeOperation.Execute(TaskExecutionMode.Execute); int afterExclude = schemaCompareOperation.ComparisonResult.Differences.Count(); Assert.True(initial == afterExclude, $"Changes should be same again after excluding/including, before {initial}, now {afterExclude}"); generateScriptOperation = new SchemaCompareGenerateScriptOperation(generateScriptParams, schemaCompareOperation.ComparisonResult); generateScriptOperation.Execute(TaskExecutionMode.Execute); string afterExcludeScript = File.ReadAllText(generateScriptParams.ScriptFilePath); Assert.True(initialScript.Length > afterExcludeScript.Length, $"Script should be affected (less statements) exclude operation, before {initialScript}, now {afterExcludeScript}"); SchemaCompareNodeParams schemaCompareincludeNodeParams = new SchemaCompareNodeParams() { OperationId = schemaCompareOperation.OperationId, DiffEntry = diff, IncludeRequest = true, TaskExecutionMode = TaskExecutionMode.Execute }; SchemaCompareIncludeExcludeNodeOperation nodeIncludeOperation = new SchemaCompareIncludeExcludeNodeOperation(schemaCompareincludeNodeParams, schemaCompareOperation.ComparisonResult); nodeIncludeOperation.Execute(TaskExecutionMode.Execute); int afterInclude = schemaCompareOperation.ComparisonResult.Differences.Count(); Assert.True(initial == afterInclude, $"Changes should be same again after excluding/including:{initial}, now {afterInclude}"); generateScriptOperation = new SchemaCompareGenerateScriptOperation(generateScriptParams, schemaCompareOperation.ComparisonResult); generateScriptOperation.Execute(TaskExecutionMode.Execute); string afterIncludeScript = File.ReadAllText(generateScriptParams.ScriptFilePath); Assert.True(initialScript.Length == afterIncludeScript.Length, $"Changes should be same as inital since we included what we excluded, before {initialScript}, now {afterIncludeScript}"); }
private static bool IsRename(DiffEntry ent) { return(ent.GetChangeType() == DiffEntry.ChangeType.RENAME || ent.GetChangeType() == DiffEntry.ChangeType.COPY); }
public virtual void CommitSubmoduleUpdate() { Git git = new Git(db); WriteTrashFile("file.txt", "content"); git.Add().AddFilepattern("file.txt").Call(); RevCommit commit = git.Commit().SetMessage("create file").Call(); WriteTrashFile("file.txt", "content2"); git.Add().AddFilepattern("file.txt").Call(); RevCommit commit2 = git.Commit().SetMessage("edit file").Call(); SubmoduleAddCommand command = new SubmoduleAddCommand(db); string path = "sub"; command.SetPath(path); string uri = db.Directory.ToURI().ToString(); command.SetURI(uri); Repository repo = command.Call(); NUnit.Framework.Assert.IsNotNull(repo); AddRepoToClose(repo); SubmoduleWalk generator = SubmoduleWalk.ForIndex(db); NUnit.Framework.Assert.IsTrue(generator.Next()); NUnit.Framework.Assert.AreEqual(path, generator.GetPath()); NUnit.Framework.Assert.AreEqual(commit2, generator.GetObjectId()); NUnit.Framework.Assert.AreEqual(uri, generator.GetModulesUrl()); NUnit.Framework.Assert.AreEqual(path, generator.GetModulesPath()); NUnit.Framework.Assert.AreEqual(uri, generator.GetConfigUrl()); Repository subModRepo = generator.GetRepository(); AddRepoToClose(subModRepo); NUnit.Framework.Assert.IsNotNull(subModRepo); NUnit.Framework.Assert.AreEqual(commit2, repo.Resolve(Constants.HEAD)); RevCommit submoduleAddCommit = git.Commit().SetMessage("submodule add").SetOnly(path ).Call(); NUnit.Framework.Assert.IsNotNull(submoduleAddCommit); RefUpdate update = repo.UpdateRef(Constants.HEAD); update.SetNewObjectId(commit); NUnit.Framework.Assert.AreEqual(RefUpdate.Result.FORCED, update.ForceUpdate()); RevCommit submoduleEditCommit = git.Commit().SetMessage("submodule add").SetOnly( path).Call(); NUnit.Framework.Assert.IsNotNull(submoduleEditCommit); TreeWalk walk = new TreeWalk(db); walk.AddTree(submoduleAddCommit.Tree); walk.AddTree(submoduleEditCommit.Tree); walk.Filter = TreeFilter.ANY_DIFF; IList <DiffEntry> diffs = DiffEntry.Scan(walk); NUnit.Framework.Assert.AreEqual(1, diffs.Count); DiffEntry subDiff = diffs[0]; NUnit.Framework.Assert.AreEqual(FileMode.GITLINK, subDiff.GetOldMode()); NUnit.Framework.Assert.AreEqual(FileMode.GITLINK, subDiff.GetNewMode()); NUnit.Framework.Assert.AreEqual(commit2, subDiff.GetOldId().ToObjectId()); NUnit.Framework.Assert.AreEqual(commit, subDiff.GetNewId().ToObjectId()); NUnit.Framework.Assert.AreEqual(path, subDiff.GetNewPath()); NUnit.Framework.Assert.AreEqual(path, subDiff.GetOldPath()); }
/// <exception cref="System.IO.IOException"></exception> private bool ProcessMerge(Candidate n) { int pCnt = n.GetParentCount(); for (int pIdx = 0; pIdx < pCnt; pIdx++) { RevCommit parent = n.GetParent(pIdx); if (parent.Has(SEEN)) { continue; } revPool.ParseHeaders(parent); } // If any single parent exactly matches the merge, follow only // that one parent through history. ObjectId[] ids = null; for (int pIdx_1 = 0; pIdx_1 < pCnt; pIdx_1++) { RevCommit parent = n.GetParent(pIdx_1); if (parent.Has(SEEN)) { continue; } if (!Find(parent, n.sourcePath)) { continue; } if (!(n is Candidate.ReverseCandidate) && idBuf.Equals(n.sourceBlob)) { n.sourceCommit = parent; Push(n); return(false); } if (ids == null) { ids = new ObjectId[pCnt]; } ids[pIdx_1] = idBuf.ToObjectId(); } // If rename detection is enabled, search for any relevant names. DiffEntry[] renames = null; if (renameDetector != null) { renames = new DiffEntry[pCnt]; for (int pIdx_2 = 0; pIdx_2 < pCnt; pIdx_2++) { RevCommit parent = n.GetParent(pIdx_2); if (parent.Has(SEEN)) { continue; } if (ids != null && ids[pIdx_2] != null) { continue; } DiffEntry r = FindRename(parent, n.sourceCommit, n.sourcePath); if (r == null) { continue; } if (n is Candidate.ReverseCandidate) { if (ids == null) { ids = new ObjectId[pCnt]; } ids[pCnt] = r.GetOldId().ToObjectId(); } else { if (0 == r.GetOldId().PrefixCompare(n.sourceBlob)) { // A 100% rename without any content change can also // skip directly to the parent. Note this bypasses an // earlier parent that had the path (above) but did not // have an exact content match. For performance reasons // we choose to follow the one parent over trying to do // possibly both parents. n.sourceCommit = parent; n.sourcePath = PathFilter.Create(r.GetOldPath()); Push(n); return(false); } } renames[pIdx_2] = r; } } // Construct the candidate for each parent. Candidate[] parents = new Candidate[pCnt]; for (int pIdx_3 = 0; pIdx_3 < pCnt; pIdx_3++) { RevCommit parent = n.GetParent(pIdx_3); if (parent.Has(SEEN)) { continue; } Candidate p; if (renames != null && renames[pIdx_3] != null) { p = n.Create(parent, PathFilter.Create(renames[pIdx_3].GetOldPath())); p.renameScore = renames[pIdx_3].GetScore(); p.sourceBlob = renames[pIdx_3].GetOldId().ToObjectId(); } else { if (ids != null && ids[pIdx_3] != null) { p = n.Create(parent, n.sourcePath); p.sourceBlob = ids[pIdx_3]; } else { continue; } } EditList editList; if (n is Candidate.ReverseCandidate && p.sourceBlob.Equals(n.sourceBlob)) { // This special case happens on ReverseCandidate forks. p.sourceText = n.sourceText; editList = new EditList(0); } else { p.LoadText(reader); editList = diffAlgorithm.Diff(textComparator, p.sourceText, n.sourceText); } if (editList.IsEmpty()) { // Ignoring whitespace (or some other special comparator) can // cause non-identical blobs to have an empty edit list. In // a case like this push the parent alone. if (n is Candidate.ReverseCandidate) { parents[pIdx_3] = p; continue; } p.regionList = n.regionList; Push(p); return(false); } p.TakeBlame(editList, n); // Only remember this parent candidate if there is at least // one region that was blamed on the parent. if (p.regionList != null) { // Reverse blame requires inverting the regions. This puts // the regions the parent deleted from us into the parent, // and retains the common regions to look at other parents // for deletions. if (n is Candidate.ReverseCandidate) { Region r = p.regionList; p.regionList = n.regionList; n.regionList = r; } parents[pIdx_3] = p; } } if (n is Candidate.ReverseCandidate) { // On a reverse blame report all deletions found in the children, // and pass on to them a copy of our region list. Candidate resultHead = null; Candidate resultTail = null; for (int pIdx_2 = 0; pIdx_2 < pCnt; pIdx_2++) { Candidate p = parents[pIdx_2]; if (p == null) { continue; } if (p.regionList != null) { Candidate r = p.Copy(p.sourceCommit); if (resultTail != null) { resultTail.queueNext = r; resultTail = r; } else { resultHead = r; resultTail = r; } } if (n.regionList != null) { p.regionList = n.regionList.DeepCopy(); Push(p); } } if (resultHead != null) { return(Result(resultHead)); } return(false); } // Push any parents that are still candidates. for (int pIdx_4 = 0; pIdx_4 < pCnt; pIdx_4++) { if (parents[pIdx_4] != null) { Push(parents[pIdx_4]); } } if (n.regionList != null) { return(Result(n)); } return(false); }
/// <summary> /// Called whenever a diff was found that is actually a rename or copy of a /// file. /// </summary> /// <remarks> /// Called whenever a diff was found that is actually a rename or copy of a /// file. /// </remarks> /// <param name="entry">the entry representing the rename/copy</param> public abstract void Renamed(DiffEntry entry);
private SchemaDifference FindDifference(IEnumerable <SchemaDifference> differences, DiffEntry diffEntry) { foreach (var difference in differences) { if (IsEqual(difference, diffEntry)) { return(difference); } else { var childDiff = FindDifference(difference.Children, diffEntry); if (childDiff != null) { return(childDiff); } } } return(null); }